hotspot/src/share/vm/classfile/vmSymbols.hpp
author johnc
Thu, 07 Apr 2011 09:53:20 -0700
changeset 9176 42d9d1010f38
parent 8676 9098d4e927e1
child 9182 ab3e9e0925ad
permissions -rw-r--r--
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer. Reviewed-by: kvn, iveresov, never, tonyp, dholmes
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7900
4c7fc6332f7e 6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents: 7436
diff changeset
     2
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5420
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
    25
#ifndef SHARE_VM_CLASSFILE_VMSYMBOLS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
    26
#define SHARE_VM_CLASSFILE_VMSYMBOLS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
    27
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
    28
#include "oops/symbol.hpp"
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
    29
#include "memory/iterator.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
    30
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
    31
// The class vmSymbols is a name space for fast lookup of
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
    32
// symbols commonly used in the VM.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// Sample usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
//
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
    36
//   Symbol* obj       = vmSymbols::java_lang_Object();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Useful sub-macros exported by this header file:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
#define VM_SYMBOL_ENUM_NAME(name)    name##_enum
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
#define VM_INTRINSIC_IGNORE(id, class, name, sig, flags) /*ignored*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
#define VM_SYMBOL_IGNORE(id, name)                       /*ignored*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
#define VM_ALIAS_IGNORE(id, id2)                         /*ignored*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// Mapping function names to values. New entries should be added below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
#define VM_SYMBOLS_DO(template, do_alias)                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  /* commonly used class names */                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  template(java_lang_System,                          "java/lang/System")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  template(java_lang_Object,                          "java/lang/Object")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  template(java_lang_Class,                           "java/lang/Class")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  template(java_lang_String,                          "java/lang/String")                         \
2336
427ce3320578 6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents: 2259
diff changeset
    55
  template(java_lang_StringValue,                     "java/lang/StringValue")                    \
2342
9a1260c3679d 6821700: tune VM flags for peak performance
kvn
parents: 2336
diff changeset
    56
  template(java_lang_StringCache,                     "java/lang/StringValue$StringCache")        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  template(java_lang_Thread,                          "java/lang/Thread")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  template(java_lang_ThreadGroup,                     "java/lang/ThreadGroup")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  template(java_lang_Cloneable,                       "java/lang/Cloneable")                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  template(java_lang_Throwable,                       "java/lang/Throwable")                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  template(java_lang_ClassLoader,                     "java/lang/ClassLoader")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  template(java_lang_ClassLoader_NativeLibrary,       "java/lang/ClassLoader\x024NativeLibrary")  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  template(java_lang_ThreadDeath,                     "java/lang/ThreadDeath")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  template(java_lang_Boolean,                         "java/lang/Boolean")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  template(java_lang_Character,                       "java/lang/Character")                      \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
    66
  template(java_lang_Character_CharacterCache,        "java/lang/Character$CharacterCache")       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  template(java_lang_Float,                           "java/lang/Float")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  template(java_lang_Double,                          "java/lang/Double")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  template(java_lang_Byte,                            "java/lang/Byte")                           \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
    70
  template(java_lang_Byte_Cache,                      "java/lang/Byte$ByteCache")                 \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  template(java_lang_Short,                           "java/lang/Short")                          \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
    72
  template(java_lang_Short_ShortCache,                "java/lang/Short$ShortCache")               \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  template(java_lang_Integer,                         "java/lang/Integer")                        \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
    74
  template(java_lang_Integer_IntegerCache,            "java/lang/Integer$IntegerCache")           \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  template(java_lang_Long,                            "java/lang/Long")                           \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
    76
  template(java_lang_Long_LongCache,                  "java/lang/Long$LongCache")                 \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  template(java_lang_Shutdown,                        "java/lang/Shutdown")                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  template(java_lang_ref_Reference,                   "java/lang/ref/Reference")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  template(java_lang_ref_SoftReference,               "java/lang/ref/SoftReference")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  template(java_lang_ref_WeakReference,               "java/lang/ref/WeakReference")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  template(java_lang_ref_FinalReference,              "java/lang/ref/FinalReference")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  template(java_lang_ref_PhantomReference,            "java/lang/ref/PhantomReference")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  template(java_lang_ref_Finalizer,                   "java/lang/ref/Finalizer")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  template(java_lang_reflect_AccessibleObject,        "java/lang/reflect/AccessibleObject")       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  template(java_lang_reflect_Method,                  "java/lang/reflect/Method")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  template(java_lang_reflect_Constructor,             "java/lang/reflect/Constructor")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  template(java_lang_reflect_Field,                   "java/lang/reflect/Field")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  template(java_lang_reflect_Array,                   "java/lang/reflect/Array")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  template(java_lang_StringBuffer,                    "java/lang/StringBuffer")                   \
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
    90
  template(java_lang_StringBuilder,                   "java/lang/StringBuilder")                  \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  template(java_lang_CharSequence,                    "java/lang/CharSequence")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  template(java_security_AccessControlContext,        "java/security/AccessControlContext")       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  template(java_security_ProtectionDomain,            "java/security/ProtectionDomain")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  template(java_io_OutputStream,                      "java/io/OutputStream")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  template(java_io_Reader,                            "java/io/Reader")                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  template(java_io_BufferedReader,                    "java/io/BufferedReader")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  template(java_io_FileInputStream,                   "java/io/FileInputStream")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  template(java_io_ByteArrayInputStream,              "java/io/ByteArrayInputStream")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  template(java_io_Serializable,                      "java/io/Serializable")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  template(java_util_Arrays,                          "java/util/Arrays")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  template(java_util_Properties,                      "java/util/Properties")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  template(java_util_Vector,                          "java/util/Vector")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  template(java_util_AbstractList,                    "java/util/AbstractList")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  template(java_util_Hashtable,                       "java/util/Hashtable")                      \
191
314312979e7a 6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents: 190
diff changeset
   105
  template(java_util_HashMap,                         "java/util/HashMap")                        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  template(java_lang_Compiler,                        "java/lang/Compiler")                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  template(sun_misc_Signal,                           "sun/misc/Signal")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  template(java_lang_AssertionStatusDirectives,       "java/lang/AssertionStatusDirectives")      \
191
314312979e7a 6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents: 190
diff changeset
   109
  template(sun_jkernel_DownloadManager,               "sun/jkernel/DownloadManager")              \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  template(getBootClassPathEntryForClass_name,        "getBootClassPathEntryForClass")            \
7900
4c7fc6332f7e 6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents: 7436
diff changeset
   111
  template(sun_misc_PostVMInitHook,                   "sun/misc/PostVMInitHook")                  \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  /* class file format tags */                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  template(tag_source_file,                           "SourceFile")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  template(tag_inner_classes,                         "InnerClasses")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  template(tag_constant_value,                        "ConstantValue")                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  template(tag_code,                                  "Code")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  template(tag_exceptions,                            "Exceptions")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  template(tag_line_number_table,                     "LineNumberTable")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  template(tag_local_variable_table,                  "LocalVariableTable")                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  template(tag_local_variable_type_table,             "LocalVariableTypeTable")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  template(tag_stack_map_table,                       "StackMapTable")                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  template(tag_synthetic,                             "Synthetic")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  template(tag_deprecated,                            "Deprecated")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  template(tag_source_debug_extension,                "SourceDebugExtension")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  template(tag_signature,                             "Signature")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  template(tag_runtime_visible_annotations,           "RuntimeVisibleAnnotations")                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  template(tag_runtime_invisible_annotations,         "RuntimeInvisibleAnnotations")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  template(tag_runtime_visible_parameter_annotations, "RuntimeVisibleParameterAnnotations")       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  template(tag_runtime_invisible_parameter_annotations,"RuntimeInvisibleParameterAnnotations")    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  template(tag_annotation_default,                    "AnnotationDefault")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  template(tag_enclosing_method,                      "EnclosingMethod")                          \
7436
dbc43da3d512 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents: 7397
diff changeset
   133
  template(tag_bootstrap_methods,                     "BootstrapMethods")                         \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  /* exception klasses: at least all exceptions thrown by the VM have entries here */             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  template(java_lang_ArithmeticException,             "java/lang/ArithmeticException")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  template(java_lang_ArrayIndexOutOfBoundsException,  "java/lang/ArrayIndexOutOfBoundsException") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  template(java_lang_ArrayStoreException,             "java/lang/ArrayStoreException")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  template(java_lang_ClassCastException,              "java/lang/ClassCastException")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  template(java_lang_ClassNotFoundException,          "java/lang/ClassNotFoundException")         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  template(java_lang_CloneNotSupportedException,      "java/lang/CloneNotSupportedException")     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  template(java_lang_IllegalAccessException,          "java/lang/IllegalAccessException")         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  template(java_lang_IllegalArgumentException,        "java/lang/IllegalArgumentException")       \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   144
  template(java_lang_IllegalStateException,           "java/lang/IllegalStateException")          \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  template(java_lang_IllegalMonitorStateException,    "java/lang/IllegalMonitorStateException")   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  template(java_lang_IllegalThreadStateException,     "java/lang/IllegalThreadStateException")    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  template(java_lang_IndexOutOfBoundsException,       "java/lang/IndexOutOfBoundsException")      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  template(java_lang_InstantiationException,          "java/lang/InstantiationException")         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  template(java_lang_InstantiationError,              "java/lang/InstantiationError")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  template(java_lang_InterruptedException,            "java/lang/InterruptedException")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  template(java_lang_LinkageError,                    "java/lang/LinkageError")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  template(java_lang_NegativeArraySizeException,      "java/lang/NegativeArraySizeException")     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  template(java_lang_NoSuchFieldException,            "java/lang/NoSuchFieldException")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  template(java_lang_NoSuchMethodException,           "java/lang/NoSuchMethodException")          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  template(java_lang_NullPointerException,            "java/lang/NullPointerException")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  template(java_lang_StringIndexOutOfBoundsException, "java/lang/StringIndexOutOfBoundsException")\
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  template(java_lang_InvalidClassException,           "java/lang/InvalidClassException")          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  template(java_lang_reflect_InvocationTargetException, "java/lang/reflect/InvocationTargetException") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  template(java_lang_Exception,                       "java/lang/Exception")                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  template(java_lang_RuntimeException,                "java/lang/RuntimeException")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  template(java_io_IOException,                       "java/io/IOException")                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  template(java_security_PrivilegedActionException,   "java/security/PrivilegedActionException")  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  /* error klasses: at least all errors thrown by the VM have entries here */                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  template(java_lang_AbstractMethodError,             "java/lang/AbstractMethodError")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  template(java_lang_ClassCircularityError,           "java/lang/ClassCircularityError")          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  template(java_lang_ClassFormatError,                "java/lang/ClassFormatError")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  template(java_lang_UnsupportedClassVersionError,    "java/lang/UnsupportedClassVersionError")   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  template(java_lang_Error,                           "java/lang/Error")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  template(java_lang_ExceptionInInitializerError,     "java/lang/ExceptionInInitializerError")    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  template(java_lang_IllegalAccessError,              "java/lang/IllegalAccessError")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  template(java_lang_IncompatibleClassChangeError,    "java/lang/IncompatibleClassChangeError")   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  template(java_lang_InternalError,                   "java/lang/InternalError")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  template(java_lang_NoClassDefFoundError,            "java/lang/NoClassDefFoundError")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  template(java_lang_NoSuchFieldError,                "java/lang/NoSuchFieldError")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  template(java_lang_NoSuchMethodError,               "java/lang/NoSuchMethodError")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  template(java_lang_OutOfMemoryError,                "java/lang/OutOfMemoryError")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  template(java_lang_UnsatisfiedLinkError,            "java/lang/UnsatisfiedLinkError")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  template(java_lang_VerifyError,                     "java/lang/VerifyError")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  template(java_lang_SecurityException,               "java/lang/SecurityException")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  template(java_lang_VirtualMachineError,             "java/lang/VirtualMachineError")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  template(java_lang_StackOverflowError,              "java/lang/StackOverflowError")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  template(java_lang_StackTraceElement,               "java/lang/StackTraceElement")              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  template(java_util_concurrent_locks_AbstractOwnableSynchronizer,   "java/util/concurrent/locks/AbstractOwnableSynchronizer") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  /* class symbols needed by intrinsics */                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, template, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  /* Support for reflection based on dynamic bytecode generation (JDK 1.4 and above) */           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  template(sun_reflect_FieldInfo,                     "sun/reflect/FieldInfo")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  template(sun_reflect_MethodInfo,                    "sun/reflect/MethodInfo")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  template(sun_reflect_MagicAccessorImpl,             "sun/reflect/MagicAccessorImpl")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  template(sun_reflect_MethodAccessorImpl,            "sun/reflect/MethodAccessorImpl")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  template(sun_reflect_ConstructorAccessorImpl,       "sun/reflect/ConstructorAccessorImpl")      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  template(sun_reflect_SerializationConstructorAccessorImpl, "sun/reflect/SerializationConstructorAccessorImpl") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  template(sun_reflect_DelegatingClassLoader,         "sun/reflect/DelegatingClassLoader")        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  template(sun_reflect_Reflection,                    "sun/reflect/Reflection")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  template(checkedExceptions_name,                    "checkedExceptions")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  template(clazz_name,                                "clazz")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  template(exceptionTypes_name,                       "exceptionTypes")                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  template(modifiers_name,                            "modifiers")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  template(newConstructor_name,                       "newConstructor")                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  template(newConstructor_signature,                  "(Lsun/reflect/MethodInfo;)Ljava/lang/reflect/Constructor;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  template(newField_name,                             "newField")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  template(newField_signature,                        "(Lsun/reflect/FieldInfo;)Ljava/lang/reflect/Field;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  template(newMethod_name,                            "newMethod")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  template(newMethod_signature,                       "(Lsun/reflect/MethodInfo;)Ljava/lang/reflect/Method;") \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   209
  /* the following two names must be in order: */                                                 \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   210
  template(invokeExact_name,                          "invokeExact")                              \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   211
  template(invokeGeneric_name,                        "invokeGeneric")                            \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   212
  template(invokeVarargs_name,                        "invokeVarargs")                            \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   213
  template(star_name,                                 "*") /*not really a name*/                  \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  template(invoke_name,                               "invoke")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  template(override_name,                             "override")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  template(parameterTypes_name,                       "parameterTypes")                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  template(returnType_name,                           "returnType")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  template(signature_name,                            "signature")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  template(slot_name,                                 "slot")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  /* Support for annotations (JDK 1.5 and above) */                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  template(annotations_name,                          "annotations")                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  template(parameter_annotations_name,                "parameterAnnotations")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  template(annotation_default_name,                   "annotationDefault")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  template(sun_reflect_ConstantPool,                  "sun/reflect/ConstantPool")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  template(constantPoolOop_name,                      "constantPoolOop")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  template(sun_reflect_UnsafeStaticFieldAccessorImpl, "sun/reflect/UnsafeStaticFieldAccessorImpl")\
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  template(base_name,                                 "base")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                                                                                                  \
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   231
  /* Support for JSR 292 & invokedynamic (JDK 1.7 and above) */                                   \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   232
  template(java_lang_invoke_InvokeDynamic,            "java/lang/invoke/InvokeDynamic")           \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   233
  template(java_lang_invoke_Linkage,                  "java/lang/invoke/Linkage")                 \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   234
  template(java_lang_invoke_CallSite,                 "java/lang/invoke/CallSite")                \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   235
  template(java_lang_invoke_MethodHandle,             "java/lang/invoke/MethodHandle")            \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   236
  template(java_lang_invoke_MethodType,               "java/lang/invoke/MethodType")              \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   237
  template(java_lang_invoke_WrongMethodTypeException, "java/lang/invoke/WrongMethodTypeException") \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   238
  template(java_lang_invoke_MethodType_signature,     "Ljava/lang/invoke/MethodType;")            \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   239
  template(java_lang_invoke_MethodHandle_signature,   "Ljava/lang/invoke/MethodHandle;")          \
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   240
  /* internal classes known only to the JVM: */                                                   \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   241
  template(java_lang_invoke_MethodTypeForm,           "java/lang/invoke/MethodTypeForm")          \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   242
  template(java_lang_invoke_MethodTypeForm_signature, "Ljava/lang/invoke/MethodTypeForm;")        \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   243
  template(java_lang_invoke_MemberName,               "java/lang/invoke/MemberName")              \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   244
  template(java_lang_invoke_MethodHandleNatives,      "java/lang/invoke/MethodHandleNatives")     \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   245
  template(java_lang_invoke_AdapterMethodHandle,      "java/lang/invoke/AdapterMethodHandle")     \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   246
  template(java_lang_invoke_BoundMethodHandle,        "java/lang/invoke/BoundMethodHandle")       \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   247
  template(java_lang_invoke_DirectMethodHandle,       "java/lang/invoke/DirectMethodHandle")      \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   248
  /* temporary transitional public names from 6839872: */                                         \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   249
  template(java_dyn_InvokeDynamic,                    "java/dyn/InvokeDynamic")         /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   250
  template(java_dyn_Linkage,                          "java/dyn/Linkage")               /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   251
  template(java_dyn_CallSite,                         "java/dyn/CallSite")              /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   252
  template(java_dyn_MethodHandle,                     "java/dyn/MethodHandle")          /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   253
  template(java_dyn_MethodType,                       "java/dyn/MethodType")            /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   254
  template(java_dyn_WrongMethodTypeException,         "java/dyn/WrongMethodTypeException") /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   255
  template(java_dyn_MethodType_signature,             "Ljava/dyn/MethodType;")          /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   256
  template(java_dyn_MethodHandle_signature,           "Ljava/dyn/MethodHandle;")        /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   257
  /* temporary transitional internal names from 6839872: */                                       \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   258
  template(java_dyn_MethodTypeForm,                   "java/dyn/MethodTypeForm")        /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   259
  template(java_dyn_MethodTypeForm_signature,         "Ljava/dyn/MethodTypeForm;")      /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   260
  template(java_dyn_MemberName,                       "java/dyn/MemberName")            /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   261
  template(java_dyn_MethodHandleNatives,              "java/dyn/MethodHandleNatives")   /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   262
  template(java_dyn_AdapterMethodHandle,              "java/dyn/AdapterMethodHandle")   /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   263
  template(java_dyn_BoundMethodHandle,                "java/dyn/BoundMethodHandle")     /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   264
  template(java_dyn_DirectMethodHandle,               "java/dyn/DirectMethodHandle")    /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   265
  /* temporary transitional internal names from EDR: */                                           \
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   266
  template(sun_dyn_MemberName,                        "sun/dyn/MemberName")             /* AllowTransitionalJSR292 ONLY */ \
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   267
  template(sun_dyn_MethodHandleImpl,                  "sun/dyn/MethodHandleImpl")       /* AllowTransitionalJSR292 ONLY */ \
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   268
  template(sun_dyn_MethodHandleNatives,               "sun/dyn/MethodHandleNatives")    /* AllowTransitionalJSR292 ONLY */ \
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   269
  template(sun_dyn_AdapterMethodHandle,               "sun/dyn/AdapterMethodHandle")    /* AllowTransitionalJSR292 ONLY */ \
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   270
  template(sun_dyn_BoundMethodHandle,                 "sun/dyn/BoundMethodHandle")      /* AllowTransitionalJSR292 ONLY */ \
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   271
  template(sun_dyn_DirectMethodHandle,                "sun/dyn/DirectMethodHandle")     /* AllowTransitionalJSR292 ONLY */ \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   272
  /* internal up-calls made only by the JVM, via class sun.invoke.MethodHandleNatives: */         \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   273
  template(findMethodHandleType_name,                 "findMethodHandleType")                     \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   274
  template(findMethodHandleType_signature,       "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/lang/invoke/MethodType;") \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   275
  template(findMethodHandleType_TRANS_signature, "(Ljava/lang/Class;[Ljava/lang/Class;)Ljava/dyn/MethodType;") /* AllowTransitionalJSR292 ONLY */ \
6463
f4362c8da849 6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents: 5882
diff changeset
   276
  template(notifyGenericMethodType_name,              "notifyGenericMethodType")                  \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   277
  template(notifyGenericMethodType_signature,         "(Ljava/lang/invoke/MethodType;)V")         \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   278
  template(notifyGenericMethodType_TRANS_signature,   "(Ljava/dyn/MethodType;)V")       /* AllowTransitionalJSR292 ONLY */ \
5882
6b2aecc4f7d8 6939203: JSR 292 needs method handle constants
jrose
parents: 5547
diff changeset
   279
  template(linkMethodHandleConstant_name,             "linkMethodHandleConstant")                 \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   280
  template(linkMethodHandleConstant_signature, "(Ljava/lang/Class;ILjava/lang/Class;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/invoke/MethodHandle;") \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   281
  template(linkMethodHandleConstant_TRANS_signature, "(Ljava/lang/Class;ILjava/lang/Class;Ljava/lang/String;Ljava/lang/Object;)Ljava/dyn/MethodHandle;") /* AllowTransitionalJSR292 ONLY */ \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   282
  template(makeDynamicCallSite_name,                  "makeDynamicCallSite")                      \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   283
  template(makeDynamicCallSite_signature, "(Ljava/lang/invoke/MethodHandle;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/Object;Ljava/lang/invoke/MemberName;I)Ljava/lang/invoke/CallSite;") \
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
   284
  template(makeDynamicCallSite_TRANS_signature, "(Ljava/dyn/MethodHandle;Ljava/lang/String;Ljava/dyn/MethodType;Ljava/lang/Object;Lsun/dyn/MemberName;I)Ljava/dyn/CallSite;") /* AllowTransitionalJSR292 ONLY */ \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   285
  template(makeDynamicCallSite_TRANS2_signature, "(Ljava/dyn/MethodHandle;Ljava/lang/String;Ljava/dyn/MethodType;Ljava/lang/Object;Ljava/dyn/MemberName;I)Ljava/dyn/CallSite;") /* AllowTransitionalJSR292 ONLY */ \
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   286
  NOT_LP64(  do_alias(machine_word_signature,         int_signature)  )                           \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   287
  LP64_ONLY( do_alias(machine_word_signature,         long_signature) )                           \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   288
                                                                                                  \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   289
  /* common method and field names */                                                             \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  template(object_initializer_name,                   "<init>")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  template(class_initializer_name,                    "<clinit>")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  template(println_name,                              "println")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  template(printStackTrace_name,                      "printStackTrace")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  template(main_name,                                 "main")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  template(name_name,                                 "name")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  template(priority_name,                             "priority")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  template(stillborn_name,                            "stillborn")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  template(group_name,                                "group")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  template(daemon_name,                               "daemon")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  template(eetop_name,                                "eetop")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  template(thread_status_name,                        "threadStatus")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  template(run_method_name,                           "run")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  template(exit_method_name,                          "exit")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  template(add_method_name,                           "add")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  template(parent_name,                               "parent")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  template(threads_name,                              "threads")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  template(groups_name,                               "groups")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  template(maxPriority_name,                          "maxPriority")                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  template(destroyed_name,                            "destroyed")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  template(vmAllowSuspension_name,                    "vmAllowSuspension")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  template(nthreads_name,                             "nthreads")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  template(ngroups_name,                              "ngroups")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  template(shutdown_method_name,                      "shutdown")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  template(finalize_method_name,                      "finalize")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  template(reference_lock_name,                       "lock")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  template(reference_discovered_name,                 "discovered")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  template(run_finalizers_on_exit_name,               "runFinalizersOnExit")                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  template(uncaughtException_name,                    "uncaughtException")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  template(dispatchUncaughtException_name,            "dispatchUncaughtException")                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  template(initializeSystemClass_name,                "initializeSystemClass")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  template(loadClass_name,                            "loadClass")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  template(loadClassInternal_name,                    "loadClassInternal")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  template(get_name,                                  "get")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  template(put_name,                                  "put")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  template(type_name,                                 "type")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  template(findNative_name,                           "findNative")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  template(deadChild_name,                            "deadChild")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  template(addClass_name,                             "addClass")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  template(getFromClass_name,                         "getFromClass")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  template(dispatch_name,                             "dispatch")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  template(getSystemClassLoader_name,                 "getSystemClassLoader")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  template(fillInStackTrace_name,                     "fillInStackTrace")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  template(getCause_name,                             "getCause")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  template(initCause_name,                            "initCause")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  template(setProperty_name,                          "setProperty")                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  template(getProperty_name,                          "getProperty")                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  template(context_name,                              "context")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  template(privilegedContext_name,                    "privilegedContext")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  template(contextClassLoader_name,                   "contextClassLoader")                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  template(inheritedAccessControlContext_name,        "inheritedAccessControlContext")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  template(isPrivileged_name,                         "isPrivileged")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  template(wait_name,                                 "wait")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  template(checkPackageAccess_name,                   "checkPackageAccess")                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  template(stackSize_name,                            "stackSize")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  template(thread_id_name,                            "tid")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  template(newInstance0_name,                         "newInstance0")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  template(limit_name,                                "limit")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  template(forName_name,                              "forName")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  template(forName0_name,                             "forName0")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  template(isJavaIdentifierStart_name,                "isJavaIdentifierStart")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  template(isJavaIdentifierPart_name,                 "isJavaIdentifierPart")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  template(exclusive_owner_thread_name,               "exclusiveOwnerThread")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  template(park_blocker_name,                         "parkBlocker")                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  template(park_event_name,                           "nativeParkEventPointer")                   \
190
e9a0a9dcd4f6 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 1
diff changeset
   355
  template(cache_field_name,                          "cache")                                    \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  template(value_name,                                "value")                                    \
191
314312979e7a 6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents: 190
diff changeset
   357
  template(frontCacheEnabled_name,                    "frontCacheEnabled")                        \
618
9641c2c8f977 6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents: 595
diff changeset
   358
  template(stringCacheEnabled_name,                   "stringCacheEnabled")                       \
2862
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   359
  template(numberOfLeadingZeros_name,                 "numberOfLeadingZeros")                     \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   360
  template(numberOfTrailingZeros_name,                "numberOfTrailingZeros")                    \
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   361
  template(bitCount_name,                             "bitCount")                                 \
2342
9a1260c3679d 6821700: tune VM flags for peak performance
kvn
parents: 2336
diff changeset
   362
  template(profile_name,                              "profile")                                  \
2348
4e71ed4c2709 6761600: Use sse 4.2 in intrinsics
cfang
parents: 2343
diff changeset
   363
  template(equals_name,                               "equals")                                   \
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   364
  template(target_name,                               "target")                                   \
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   365
  template(toString_name,                             "toString")                                 \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   366
  template(values_name,                               "values")                                   \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   367
  template(receiver_name,                             "receiver")                                 \
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 2534
diff changeset
   368
  template(vmmethod_name,                             "vmmethod")                                 \
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   369
  template(vmtarget_name,                             "vmtarget")                                 \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   370
  template(vmentry_name,                              "vmentry")                                  \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   371
  template(vmslots_name,                              "vmslots")                                  \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   372
  template(vmindex_name,                              "vmindex")                                  \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   373
  template(vmargslot_name,                            "vmargslot")                                \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   374
  template(flags_name,                                "flags")                                    \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   375
  template(argument_name,                             "argument")                                 \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   376
  template(conversion_name,                           "conversion")                               \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   377
  template(rtype_name,                                "rtype")                                    \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   378
  template(ptypes_name,                               "ptypes")                                   \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   379
  template(form_name,                                 "form")                                     \
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 2348
diff changeset
   380
  template(erasedType_name,                           "erasedType")                               \
6463
f4362c8da849 6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents: 5882
diff changeset
   381
  template(genericInvoker_name,                       "genericInvoker")                           \
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   382
  template(append_name,                               "append")                                   \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  /* non-intrinsic name/signature pairs: */                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  template(register_method_name,                      "register")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  do_alias(register_method_signature,         object_void_signature)                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  /* name symbols needed by intrinsics */                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, VM_SYMBOL_IGNORE, template, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  /* common signatures names */                                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  template(void_method_signature,                     "()V")                                      \
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   393
  template(void_boolean_signature,                    "()Z")                                      \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   394
  template(void_byte_signature,                       "()B")                                      \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   395
  template(void_char_signature,                       "()C")                                      \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   396
  template(void_short_signature,                      "()S")                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  template(void_int_signature,                        "()I")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  template(void_long_signature,                       "()J")                                      \
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   399
  template(void_float_signature,                      "()F")                                      \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   400
  template(void_double_signature,                     "()D")                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  template(int_void_signature,                        "(I)V")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  template(int_int_signature,                         "(I)I")                                     \
5352
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   403
  template(char_char_signature,                       "(C)C")                                     \
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   404
  template(short_short_signature,                     "(S)S")                                     \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  template(int_bool_signature,                        "(I)Z")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  template(float_int_signature,                       "(F)I")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  template(double_long_signature,                     "(D)J")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  template(double_double_signature,                   "(D)D")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  template(int_float_signature,                       "(I)F")                                     \
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   410
  template(long_int_signature,                        "(J)I")                                     \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  template(long_long_signature,                       "(J)J")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  template(long_double_signature,                     "(J)D")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  template(byte_signature,                            "B")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  template(char_signature,                            "C")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  template(double_signature,                          "D")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  template(float_signature,                           "F")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  template(int_signature,                             "I")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  template(long_signature,                            "J")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  template(short_signature,                           "S")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  template(bool_signature,                            "Z")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  template(void_signature,                            "V")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  template(byte_array_signature,                      "[B")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  template(char_array_signature,                      "[C")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  template(object_void_signature,                     "(Ljava/lang/Object;)V")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  template(object_int_signature,                      "(Ljava/lang/Object;)I")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  template(object_boolean_signature,                  "(Ljava/lang/Object;)Z")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  template(string_void_signature,                     "(Ljava/lang/String;)V")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  template(string_int_signature,                      "(Ljava/lang/String;)I")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  template(throwable_void_signature,                  "(Ljava/lang/Throwable;)V")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  template(void_throwable_signature,                  "()Ljava/lang/Throwable;")                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  template(throwable_throwable_signature,             "(Ljava/lang/Throwable;)Ljava/lang/Throwable;")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  template(class_void_signature,                      "(Ljava/lang/Class;)V")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  template(class_int_signature,                       "(Ljava/lang/Class;)I")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  template(class_boolean_signature,                   "(Ljava/lang/Class;)Z")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  template(throwable_string_void_signature,           "(Ljava/lang/Throwable;Ljava/lang/String;)V")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  template(string_array_void_signature,               "([Ljava/lang/String;)V")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  template(string_array_string_array_void_signature,  "([Ljava/lang/String;[Ljava/lang/String;)V")                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  template(thread_throwable_void_signature,           "(Ljava/lang/Thread;Ljava/lang/Throwable;)V")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  template(thread_void_signature,                     "(Ljava/lang/Thread;)V")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  template(threadgroup_runnable_void_signature,       "(Ljava/lang/ThreadGroup;Ljava/lang/Runnable;)V")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  template(threadgroup_string_void_signature,         "(Ljava/lang/ThreadGroup;Ljava/lang/String;)V")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  template(string_class_signature,                    "(Ljava/lang/String;)Ljava/lang/Class;")                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  template(object_object_object_signature,            "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  template(string_string_string_signature,            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  template(string_string_signature,                   "(Ljava/lang/String;)Ljava/lang/String;")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  template(classloader_string_long_signature,         "(Ljava/lang/ClassLoader;Ljava/lang/String;)J")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  template(byte_array_void_signature,                 "([B)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  template(char_array_void_signature,                 "([C)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  template(int_int_void_signature,                    "(II)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  template(long_long_void_signature,                  "(JJ)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  template(void_classloader_signature,                "()Ljava/lang/ClassLoader;")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  template(void_object_signature,                     "()Ljava/lang/Object;")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  template(void_class_signature,                      "()Ljava/lang/Class;")                                      \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   454
  template(void_string_signature,                     "()Ljava/lang/String;")                                     \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   455
  template(object_array_object_signature,             "([Ljava/lang/Object;)Ljava/lang/Object;")                  \
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   456
  template(object_object_array_object_signature,      "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;")\
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  template(exception_void_signature,                  "(Ljava/lang/Exception;)V")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  template(protectiondomain_signature,                "[Ljava/security/ProtectionDomain;")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  template(accesscontrolcontext_signature,            "Ljava/security/AccessControlContext;")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  template(class_protectiondomain_signature,          "(Ljava/lang/Class;Ljava/security/ProtectionDomain;)V")     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  template(thread_signature,                          "Ljava/lang/Thread;")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  template(thread_array_signature,                    "[Ljava/lang/Thread;")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  template(threadgroup_signature,                     "Ljava/lang/ThreadGroup;")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  template(threadgroup_array_signature,               "[Ljava/lang/ThreadGroup;")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  template(class_array_signature,                     "[Ljava/lang/Class;")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  template(classloader_signature,                     "Ljava/lang/ClassLoader;")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  template(object_signature,                          "Ljava/lang/Object;")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  template(class_signature,                           "Ljava/lang/Class;")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  template(string_signature,                          "Ljava/lang/String;")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  template(reference_signature,                       "Ljava/lang/ref/Reference;")                                \
1890
9ce941df84eb 4670071: loadClassInternal is too restrictive.
acorn
parents: 670
diff changeset
   471
  template(concurrenthashmap_signature,               "Ljava/util/concurrent/ConcurrentHashMap;")                 \
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   472
  template(String_StringBuilder_signature,            "(Ljava/lang/String;)Ljava/lang/StringBuilder;")            \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   473
  template(int_StringBuilder_signature,               "(I)Ljava/lang/StringBuilder;")                             \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   474
  template(char_StringBuilder_signature,              "(C)Ljava/lang/StringBuilder;")                             \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   475
  template(String_StringBuffer_signature,             "(Ljava/lang/String;)Ljava/lang/StringBuffer;")             \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   476
  template(int_StringBuffer_signature,                "(I)Ljava/lang/StringBuffer;")                              \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   477
  template(char_StringBuffer_signature,               "(C)Ljava/lang/StringBuffer;")                              \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   478
  template(int_String_signature,                      "(I)Ljava/lang/String;")                                    \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  /* signature symbols needed by intrinsics */                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, template, VM_ALIAS_IGNORE)            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
                                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  /* symbol aliases needed by intrinsics */                                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  VM_INTRINSICS_DO(VM_INTRINSIC_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, do_alias)           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
                                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  /* returned by the C1 compiler in case there's not enough memory to allocate a new symbol*/                     \
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
   486
  template(dummy_symbol,                              "illegal symbol")                                           \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
                                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  /* used by ClassFormatError when class name is not known yet */                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  template(unknown_class_name,                        "<Unknown>")                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
                                                                                                                  \
1890
9ce941df84eb 4670071: loadClassInternal is too restrictive.
acorn
parents: 670
diff changeset
   491
  /* used to identify class loaders handling parallel class loading */                                            \
2265
56439ca57904 6819853: VM does not detect JDK which supports parallel class loaders
acorn
parents: 2105
diff changeset
   492
  template(parallelCapable_name,                      "parallelLockMap")                                          \
1890
9ce941df84eb 4670071: loadClassInternal is too restrictive.
acorn
parents: 670
diff changeset
   493
                                                                                                                  \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  /* JVM monitoring and management support */                                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  template(java_lang_StackTraceElement_array,          "[Ljava/lang/StackTraceElement;")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  template(java_lang_management_ThreadState,           "java/lang/management/ThreadState")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  template(java_lang_management_MemoryUsage,           "java/lang/management/MemoryUsage")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  template(java_lang_management_ThreadInfo,            "java/lang/management/ThreadInfo")                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  template(sun_management_ManagementFactory,           "sun/management/ManagementFactory")                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  template(sun_management_Sensor,                      "sun/management/Sensor")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  template(sun_management_Agent,                       "sun/management/Agent")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  template(createMemoryPoolMBean_name,                 "createMemoryPoolMBean")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  template(createMemoryManagerMBean_name,              "createMemoryManagerMBean")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  template(createGarbageCollectorMBean_name,           "createGarbageCollectorMBean")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  template(createMemoryPoolMBean_signature,            "(Ljava/lang/String;ZJJ)Ljava/lang/management/MemoryPoolMBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  template(createMemoryManagerMBean_signature,         "(Ljava/lang/String;)Ljava/lang/management/MemoryManagerMBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  template(createGarbageCollectorMBean_signature,      "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/management/GarbageCollectorMBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  template(trigger_name,                               "trigger")                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  template(clear_name,                                 "clear")                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  template(trigger_method_signature,                   "(ILjava/lang/management/MemoryUsage;)V")                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  template(startAgent_name,                            "startAgent")                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  template(java_lang_management_ThreadInfo_constructor_signature, "(Ljava/lang/Thread;ILjava/lang/Object;Ljava/lang/Thread;JJJJ[Ljava/lang/StackTraceElement;)V") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  template(java_lang_management_ThreadInfo_with_locks_constructor_signature, "(Ljava/lang/Thread;ILjava/lang/Object;Ljava/lang/Thread;JJJJ[Ljava/lang/StackTraceElement;[Ljava/lang/Object;[I[Ljava/lang/Object;)V") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  template(long_long_long_long_void_signature,         "(JJJJ)V")                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
                                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  template(java_lang_management_MemoryPoolMXBean,      "java/lang/management/MemoryPoolMXBean")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  template(java_lang_management_MemoryManagerMXBean,   "java/lang/management/MemoryManagerMXBean")                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  template(java_lang_management_GarbageCollectorMXBean,"java/lang/management/GarbageCollectorMXBean")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  template(createMemoryPool_name,                      "createMemoryPool")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  template(createMemoryManager_name,                   "createMemoryManager")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  template(createGarbageCollector_name,                "createGarbageCollector")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  template(createMemoryPool_signature,                 "(Ljava/lang/String;ZJJ)Ljava/lang/management/MemoryPoolMXBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  template(createMemoryManager_signature,              "(Ljava/lang/String;)Ljava/lang/management/MemoryManagerMXBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  template(createGarbageCollector_signature,           "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/management/GarbageCollectorMXBean;") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  template(addThreadDumpForMonitors_name,              "addThreadDumpForMonitors")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  template(addThreadDumpForSynchronizers_name,         "addThreadDumpForSynchronizers")                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  template(addThreadDumpForMonitors_signature,         "(Ljava/lang/management/ThreadInfo;[Ljava/lang/Object;[I)V") \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  template(addThreadDumpForSynchronizers_signature,    "(Ljava/lang/management/ThreadInfo;[Ljava/lang/Object;)V")   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
                                                                                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  /* JVMTI/java.lang.instrument support and VM Attach mechanism */                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  template(sun_misc_VMSupport,                         "sun/misc/VMSupport")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  template(appendToClassPathForInstrumentation_name,   "appendToClassPathForInstrumentation")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  do_alias(appendToClassPathForInstrumentation_signature, string_void_signature)                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  template(serializePropertiesToByteArray_name,        "serializePropertiesToByteArray")                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  template(serializePropertiesToByteArray_signature,   "()[B")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  template(serializeAgentPropertiesToByteArray_name,   "serializeAgentPropertiesToByteArray")                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  template(classRedefinedCount_name,                   "classRedefinedCount")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  /*end*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
// Here are all the intrinsics known to the runtime and the CI.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
// Each intrinsic consists of a public enum name (like _hashCode),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
// followed by a specification of its klass, name, and signature:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
//    template(<id>,  <klass>,  <name>, <sig>, <FCODE>)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
// If you add an intrinsic here, you must also define its name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
// and signature as members of the VM symbols.  The VM symbols for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
// the intrinsic name and signature may be defined above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
// Because the VM_SYMBOLS_DO macro makes reference to VM_INTRINSICS_DO,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
// you can also define an intrinsic's name and/or signature locally to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
// intrinsic, if this makes sense.  (It often does make sense.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
// For example:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
//    do_intrinsic(_foo,  java_lang_Object,  foo_name, foo_signature, F_xx)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
//     do_name(     foo_name, "foo")
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
//     do_signature(foo_signature, "()F")
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
// klass      = vmSymbols::java_lang_Object()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
// name       = vmSymbols::foo_name()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// signature  = vmSymbols::foo_signature()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
// The name and/or signature might be a "well known" symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
// like "equal" or "()I", in which case there will be no local
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
// re-definition of the symbol.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
// The do_class, do_name, and do_signature calls are all used for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
// same purpose:  Define yet another VM symbol.  They could all be merged
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
// into a common 'do_symbol' call, but it seems useful to record our
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
// intentions here about kinds of symbols (class vs. name vs. signature).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
// The F_xx is one of the Flags enum; see below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
// for Emacs: (let ((c-backslash-column 120) (c-backslash-max-column 120)) (c-backslash-region (point) (point-max) nil t))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
#define VM_INTRINSICS_DO(do_intrinsic, do_class, do_name, do_signature, do_alias)                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  do_intrinsic(_hashCode,                 java_lang_Object,       hashCode_name, void_int_signature,             F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
   do_name(     hashCode_name,                                   "hashCode")                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  do_intrinsic(_getClass,                 java_lang_Object,       getClass_name, void_class_signature,           F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
   do_name(     getClass_name,                                   "getClass")                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  do_intrinsic(_clone,                    java_lang_Object,       clone_name, void_object_signature,             F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
   do_name(     clone_name,                                      "clone")                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  /* Math & StrictMath intrinsics are defined in terms of just a few signatures: */                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  do_class(java_lang_Math,                "java/lang/Math")                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  do_class(java_lang_StrictMath,          "java/lang/StrictMath")                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  do_signature(double2_double_signature,  "(DD)D")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  do_signature(int2_int_signature,        "(II)I")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  /* here are the math names, all together: */                                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  do_name(abs_name,"abs")       do_name(sin_name,"sin")         do_name(cos_name,"cos")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  do_name(tan_name,"tan")       do_name(atan2_name,"atan2")     do_name(sqrt_name,"sqrt")                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  do_name(log_name,"log")       do_name(log10_name,"log10")     do_name(pow_name,"pow")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  do_name(exp_name,"exp")       do_name(min_name,"min")         do_name(max_name,"max")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  do_intrinsic(_dabs,                     java_lang_Math,         abs_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  do_intrinsic(_dsin,                     java_lang_Math,         sin_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  do_intrinsic(_dcos,                     java_lang_Math,         cos_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  do_intrinsic(_dtan,                     java_lang_Math,         tan_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  do_intrinsic(_datan2,                   java_lang_Math,         atan2_name, double2_double_signature,          F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  do_intrinsic(_dsqrt,                    java_lang_Math,         sqrt_name,  double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  do_intrinsic(_dlog,                     java_lang_Math,         log_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  do_intrinsic(_dlog10,                   java_lang_Math,         log10_name, double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  do_intrinsic(_dpow,                     java_lang_Math,         pow_name,   double2_double_signature,          F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  do_intrinsic(_dexp,                     java_lang_Math,         exp_name,   double_double_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  do_intrinsic(_min,                      java_lang_Math,         min_name,   int2_int_signature,                F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  do_intrinsic(_max,                      java_lang_Math,         max_name,   int2_int_signature,                F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  do_intrinsic(_floatToRawIntBits,        java_lang_Float,        floatToRawIntBits_name,   float_int_signature, F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
   do_name(     floatToRawIntBits_name,                          "floatToRawIntBits")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  do_intrinsic(_floatToIntBits,           java_lang_Float,        floatToIntBits_name,      float_int_signature, F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
   do_name(     floatToIntBits_name,                             "floatToIntBits")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  do_intrinsic(_intBitsToFloat,           java_lang_Float,        intBitsToFloat_name,      int_float_signature, F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
   do_name(     intBitsToFloat_name,                             "intBitsToFloat")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  do_intrinsic(_doubleToRawLongBits,      java_lang_Double,       doubleToRawLongBits_name, double_long_signature, F_S) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
   do_name(     doubleToRawLongBits_name,                        "doubleToRawLongBits")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  do_intrinsic(_doubleToLongBits,         java_lang_Double,       doubleToLongBits_name,    double_long_signature, F_S) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
   do_name(     doubleToLongBits_name,                           "doubleToLongBits")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  do_intrinsic(_longBitsToDouble,         java_lang_Double,       longBitsToDouble_name,    long_double_signature, F_S) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
   do_name(     longBitsToDouble_name,                           "longBitsToDouble")                                    \
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   620
                                                                                                                        \
2862
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   621
  do_intrinsic(_numberOfLeadingZeros_i,   java_lang_Integer,      numberOfLeadingZeros_name,int_int_signature,   F_S)   \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   622
  do_intrinsic(_numberOfLeadingZeros_l,   java_lang_Long,         numberOfLeadingZeros_name,long_int_signature,  F_S)   \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   623
                                                                                                                        \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   624
  do_intrinsic(_numberOfTrailingZeros_i,  java_lang_Integer,      numberOfTrailingZeros_name,int_int_signature,  F_S)   \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   625
  do_intrinsic(_numberOfTrailingZeros_l,  java_lang_Long,         numberOfTrailingZeros_name,long_int_signature, F_S)   \
fad636edf18f 6823354: Add intrinsics for {Integer,Long}.{numberOfLeadingZeros,numberOfTrailingZeros}()
twisti
parents: 2570
diff changeset
   626
                                                                                                                        \
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   627
  do_intrinsic(_bitCount_i,               java_lang_Integer,      bitCount_name,            int_int_signature,   F_S)   \
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   628
  do_intrinsic(_bitCount_l,               java_lang_Long,         bitCount_name,            long_int_signature,  F_S)   \
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   629
                                                                                                                        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  do_intrinsic(_reverseBytes_i,           java_lang_Integer,      reverseBytes_name,        int_int_signature,   F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
   do_name(     reverseBytes_name,                               "reverseBytes")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  do_intrinsic(_reverseBytes_l,           java_lang_Long,         reverseBytes_name,        long_long_signature, F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
    /*  (symbol reverseBytes_name defined above) */                                                                     \
5352
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   634
  do_intrinsic(_reverseBytes_c,           java_lang_Character,    reverseBytes_name,        char_char_signature, F_S)   \
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   635
    /*  (symbol reverseBytes_name defined above) */                                                                     \
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   636
  do_intrinsic(_reverseBytes_s,           java_lang_Short,        reverseBytes_name,        short_short_signature, F_S) \
cee8f7acb7bc 6946040: add intrinsic for short and char reverseBytes
never
parents: 4573
diff changeset
   637
    /*  (symbol reverseBytes_name defined above) */                                                                     \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  do_intrinsic(_identityHashCode,         java_lang_System,       identityHashCode_name, object_int_signature,   F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
   do_name(     identityHashCode_name,                           "identityHashCode")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  do_intrinsic(_currentTimeMillis,        java_lang_System,       currentTimeMillis_name, void_long_signature,   F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
   do_name(     currentTimeMillis_name,                          "currentTimeMillis")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  do_intrinsic(_nanoTime,                 java_lang_System,       nanoTime_name,          void_long_signature,   F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
   do_name(     nanoTime_name,                                   "nanoTime")                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  do_intrinsic(_arraycopy,                java_lang_System,       arraycopy_name, arraycopy_signature,           F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
   do_name(     arraycopy_name,                                  "arraycopy")                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
   do_signature(arraycopy_signature,                             "(Ljava/lang/Object;ILjava/lang/Object;II)V")          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  do_intrinsic(_isInterrupted,            java_lang_Thread,       isInterrupted_name, isInterrupted_signature,   F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
   do_name(     isInterrupted_name,                              "isInterrupted")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
   do_signature(isInterrupted_signature,                         "(Z)Z")                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  do_intrinsic(_currentThread,            java_lang_Thread,       currentThread_name, currentThread_signature,   F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
   do_name(     currentThread_name,                              "currentThread")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
   do_signature(currentThread_signature,                         "()Ljava/lang/Thread;")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  /* reflective intrinsics, for java/lang/Class, etc. */                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  do_intrinsic(_isAssignableFrom,         java_lang_Class,        isAssignableFrom_name, class_boolean_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
   do_name(     isAssignableFrom_name,                           "isAssignableFrom")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  do_intrinsic(_isInstance,               java_lang_Class,        isInstance_name, object_boolean_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
   do_name(     isInstance_name,                                 "isInstance")                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  do_intrinsic(_getModifiers,             java_lang_Class,        getModifiers_name, void_int_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
   do_name(     getModifiers_name,                               "getModifiers")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  do_intrinsic(_isInterface,              java_lang_Class,        isInterface_name, void_boolean_signature,      F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
   do_name(     isInterface_name,                                "isInterface")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  do_intrinsic(_isArray,                  java_lang_Class,        isArray_name, void_boolean_signature,          F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
   do_name(     isArray_name,                                    "isArray")                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  do_intrinsic(_isPrimitive,              java_lang_Class,        isPrimitive_name, void_boolean_signature,      F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
   do_name(     isPrimitive_name,                                "isPrimitive")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  do_intrinsic(_getSuperclass,            java_lang_Class,        getSuperclass_name, void_class_signature,      F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
   do_name(     getSuperclass_name,                              "getSuperclass")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  do_intrinsic(_getComponentType,         java_lang_Class,        getComponentType_name, void_class_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
   do_name(     getComponentType_name,                           "getComponentType")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  do_intrinsic(_getClassAccessFlags,      sun_reflect_Reflection, getClassAccessFlags_name, class_int_signature, F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
   do_name(     getClassAccessFlags_name,                        "getClassAccessFlags")                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  do_intrinsic(_getLength,                java_lang_reflect_Array, getLength_name, object_int_signature,         F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
   do_name(     getLength_name,                                   "getLength")                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  do_intrinsic(_getCallerClass,           sun_reflect_Reflection, getCallerClass_name, getCallerClass_signature, F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
   do_name(     getCallerClass_name,                             "getCallerClass")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
   do_signature(getCallerClass_signature,                        "(I)Ljava/lang/Class;")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  do_intrinsic(_newArray,                 java_lang_reflect_Array, newArray_name, newArray_signature,            F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
   do_name(     newArray_name,                                    "newArray")                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
   do_signature(newArray_signature,                               "(Ljava/lang/Class;I)Ljava/lang/Object;")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  do_intrinsic(_copyOf,                   java_util_Arrays,       copyOf_name, copyOf_signature,                 F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
   do_name(     copyOf_name,                                     "copyOf")                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
   do_signature(copyOf_signature,             "([Ljava/lang/Object;ILjava/lang/Class;)[Ljava/lang/Object;")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  do_intrinsic(_copyOfRange,              java_util_Arrays,       copyOfRange_name, copyOfRange_signature,       F_S)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
   do_name(     copyOfRange_name,                                "copyOfRange")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
   do_signature(copyOfRange_signature,        "([Ljava/lang/Object;IILjava/lang/Class;)[Ljava/lang/Object;")            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
                                                                                                                        \
595
a2be4c89de81 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 218
diff changeset
   696
  do_intrinsic(_equalsC,                  java_util_Arrays,       equals_name,    equalsC_signature,             F_S)   \
a2be4c89de81 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 218
diff changeset
   697
   do_signature(equalsC_signature,                               "([C[C)Z")                                             \
a2be4c89de81 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 218
diff changeset
   698
                                                                                                                        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  do_intrinsic(_compareTo,                java_lang_String,       compareTo_name, string_int_signature,          F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
   do_name(     compareTo_name,                                  "compareTo")                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  do_intrinsic(_indexOf,                  java_lang_String,       indexOf_name, string_int_signature,            F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
   do_name(     indexOf_name,                                    "indexOf")                                             \
2348
4e71ed4c2709 6761600: Use sse 4.2 in intrinsics
cfang
parents: 2343
diff changeset
   703
  do_intrinsic(_equals,                   java_lang_String,       equals_name, object_boolean_signature,         F_R)   \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  do_class(java_nio_Buffer,               "java/nio/Buffer")                                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  do_intrinsic(_checkIndex,               java_nio_Buffer,        checkIndex_name, int_int_signature,            F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
   do_name(     checkIndex_name,                                 "checkIndex")                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
                                                                                                                        \
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8676
diff changeset
   709
  /* java/lang/ref/Reference */                                                                                         \
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8676
diff changeset
   710
  do_intrinsic(_Reference_get,            java_lang_ref_Reference, get_name,    void_object_signature, F_R)             \
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8676
diff changeset
   711
                                                                                                                        \
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8676
diff changeset
   712
                                                                                                                        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  do_class(sun_misc_AtomicLongCSImpl,     "sun/misc/AtomicLongCSImpl")                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  do_intrinsic(_get_AtomicLong,           sun_misc_AtomicLongCSImpl, get_name, void_long_signature,              F_R)   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  /*   (symbols get_name and void_long_signature defined above) */                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  do_intrinsic(_attemptUpdate,            sun_misc_AtomicLongCSImpl, attemptUpdate_name, attemptUpdate_signature, F_R)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
   do_name(     attemptUpdate_name,                                 "attemptUpdate")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
   do_signature(attemptUpdate_signature,                            "(JJ)Z")                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  /* support for sun.misc.Unsafe */                                                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  do_class(sun_misc_Unsafe,               "sun/misc/Unsafe")                                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  do_intrinsic(_allocateInstance,         sun_misc_Unsafe,        allocateInstance_name, allocateInstance_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
   do_name(     allocateInstance_name,                           "allocateInstance")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
   do_signature(allocateInstance_signature,   "(Ljava/lang/Class;)Ljava/lang/Object;")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  do_intrinsic(_copyMemory,               sun_misc_Unsafe,        copyMemory_name, copyMemory_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
   do_name(     copyMemory_name,                                 "copyMemory")                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
   do_signature(copyMemory_signature,         "(Ljava/lang/Object;JLjava/lang/Object;JJ)V")                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  do_intrinsic(_park,                     sun_misc_Unsafe,        park_name, park_signature,                     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
   do_name(     park_name,                                       "park")                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
   do_signature(park_signature,                                  "(ZJ)V")                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  do_intrinsic(_unpark,                   sun_misc_Unsafe,        unpark_name, unpark_signature,                 F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
   do_name(     unpark_name,                                     "unpark")                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
   do_alias(    unpark_signature,                               /*(LObject;)V*/ object_void_signature)                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  /* unsafe memory references (there are a lot of them...) */                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  do_signature(getObject_signature,       "(Ljava/lang/Object;J)Ljava/lang/Object;")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  do_signature(putObject_signature,       "(Ljava/lang/Object;JLjava/lang/Object;)V")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  do_signature(getBoolean_signature,      "(Ljava/lang/Object;J)Z")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  do_signature(putBoolean_signature,      "(Ljava/lang/Object;JZ)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  do_signature(getByte_signature,         "(Ljava/lang/Object;J)B")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  do_signature(putByte_signature,         "(Ljava/lang/Object;JB)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  do_signature(getShort_signature,        "(Ljava/lang/Object;J)S")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  do_signature(putShort_signature,        "(Ljava/lang/Object;JS)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  do_signature(getChar_signature,         "(Ljava/lang/Object;J)C")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  do_signature(putChar_signature,         "(Ljava/lang/Object;JC)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  do_signature(getInt_signature,          "(Ljava/lang/Object;J)I")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  do_signature(putInt_signature,          "(Ljava/lang/Object;JI)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  do_signature(getLong_signature,         "(Ljava/lang/Object;J)J")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  do_signature(putLong_signature,         "(Ljava/lang/Object;JJ)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  do_signature(getFloat_signature,        "(Ljava/lang/Object;J)F")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  do_signature(putFloat_signature,        "(Ljava/lang/Object;JF)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  do_signature(getDouble_signature,       "(Ljava/lang/Object;J)D")                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  do_signature(putDouble_signature,       "(Ljava/lang/Object;JD)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  do_name(getObject_name,"getObject")           do_name(putObject_name,"putObject")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  do_name(getBoolean_name,"getBoolean")         do_name(putBoolean_name,"putBoolean")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  do_name(getByte_name,"getByte")               do_name(putByte_name,"putByte")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  do_name(getShort_name,"getShort")             do_name(putShort_name,"putShort")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  do_name(getChar_name,"getChar")               do_name(putChar_name,"putChar")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  do_name(getInt_name,"getInt")                 do_name(putInt_name,"putInt")                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  do_name(getLong_name,"getLong")               do_name(putLong_name,"putLong")                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
  do_name(getFloat_name,"getFloat")             do_name(putFloat_name,"putFloat")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  do_name(getDouble_name,"getDouble")           do_name(putDouble_name,"putDouble")                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  do_intrinsic(_getObject,                sun_misc_Unsafe,        getObject_name, getObject_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  do_intrinsic(_getBoolean,               sun_misc_Unsafe,        getBoolean_name, getBoolean_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  do_intrinsic(_getByte,                  sun_misc_Unsafe,        getByte_name, getByte_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  do_intrinsic(_getShort,                 sun_misc_Unsafe,        getShort_name, getShort_signature,             F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  do_intrinsic(_getChar,                  sun_misc_Unsafe,        getChar_name, getChar_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  do_intrinsic(_getInt,                   sun_misc_Unsafe,        getInt_name, getInt_signature,                 F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  do_intrinsic(_getLong,                  sun_misc_Unsafe,        getLong_name, getLong_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  do_intrinsic(_getFloat,                 sun_misc_Unsafe,        getFloat_name, getFloat_signature,             F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  do_intrinsic(_getDouble,                sun_misc_Unsafe,        getDouble_name, getDouble_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  do_intrinsic(_putObject,                sun_misc_Unsafe,        putObject_name, putObject_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  do_intrinsic(_putBoolean,               sun_misc_Unsafe,        putBoolean_name, putBoolean_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  do_intrinsic(_putByte,                  sun_misc_Unsafe,        putByte_name, putByte_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  do_intrinsic(_putShort,                 sun_misc_Unsafe,        putShort_name, putShort_signature,             F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  do_intrinsic(_putChar,                  sun_misc_Unsafe,        putChar_name, putChar_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  do_intrinsic(_putInt,                   sun_misc_Unsafe,        putInt_name, putInt_signature,                 F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  do_intrinsic(_putLong,                  sun_misc_Unsafe,        putLong_name, putLong_signature,               F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  do_intrinsic(_putFloat,                 sun_misc_Unsafe,        putFloat_name, putFloat_signature,             F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  do_intrinsic(_putDouble,                sun_misc_Unsafe,        putDouble_name, putDouble_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  do_name(getObjectVolatile_name,"getObjectVolatile")   do_name(putObjectVolatile_name,"putObjectVolatile")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  do_name(getBooleanVolatile_name,"getBooleanVolatile") do_name(putBooleanVolatile_name,"putBooleanVolatile")           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  do_name(getByteVolatile_name,"getByteVolatile")       do_name(putByteVolatile_name,"putByteVolatile")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  do_name(getShortVolatile_name,"getShortVolatile")     do_name(putShortVolatile_name,"putShortVolatile")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  do_name(getCharVolatile_name,"getCharVolatile")       do_name(putCharVolatile_name,"putCharVolatile")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  do_name(getIntVolatile_name,"getIntVolatile")         do_name(putIntVolatile_name,"putIntVolatile")                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  do_name(getLongVolatile_name,"getLongVolatile")       do_name(putLongVolatile_name,"putLongVolatile")                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  do_name(getFloatVolatile_name,"getFloatVolatile")     do_name(putFloatVolatile_name,"putFloatVolatile")               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  do_name(getDoubleVolatile_name,"getDoubleVolatile")   do_name(putDoubleVolatile_name,"putDoubleVolatile")             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  do_intrinsic(_getObjectVolatile,        sun_misc_Unsafe,        getObjectVolatile_name, getObject_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  do_intrinsic(_getBooleanVolatile,       sun_misc_Unsafe,        getBooleanVolatile_name, getBoolean_signature, F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  do_intrinsic(_getByteVolatile,          sun_misc_Unsafe,        getByteVolatile_name, getByte_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  do_intrinsic(_getShortVolatile,         sun_misc_Unsafe,        getShortVolatile_name, getShort_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  do_intrinsic(_getCharVolatile,          sun_misc_Unsafe,        getCharVolatile_name, getChar_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  do_intrinsic(_getIntVolatile,           sun_misc_Unsafe,        getIntVolatile_name, getInt_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  do_intrinsic(_getLongVolatile,          sun_misc_Unsafe,        getLongVolatile_name, getLong_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  do_intrinsic(_getFloatVolatile,         sun_misc_Unsafe,        getFloatVolatile_name, getFloat_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  do_intrinsic(_getDoubleVolatile,        sun_misc_Unsafe,        getDoubleVolatile_name, getDouble_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  do_intrinsic(_putObjectVolatile,        sun_misc_Unsafe,        putObjectVolatile_name, putObject_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  do_intrinsic(_putBooleanVolatile,       sun_misc_Unsafe,        putBooleanVolatile_name, putBoolean_signature, F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  do_intrinsic(_putByteVolatile,          sun_misc_Unsafe,        putByteVolatile_name, putByte_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  do_intrinsic(_putShortVolatile,         sun_misc_Unsafe,        putShortVolatile_name, putShort_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  do_intrinsic(_putCharVolatile,          sun_misc_Unsafe,        putCharVolatile_name, putChar_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  do_intrinsic(_putIntVolatile,           sun_misc_Unsafe,        putIntVolatile_name, putInt_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  do_intrinsic(_putLongVolatile,          sun_misc_Unsafe,        putLongVolatile_name, putLong_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  do_intrinsic(_putFloatVolatile,         sun_misc_Unsafe,        putFloatVolatile_name, putFloat_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  do_intrinsic(_putDoubleVolatile,        sun_misc_Unsafe,        putDoubleVolatile_name, putDouble_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  /* %%% these are redundant except perhaps for getAddress, but Unsafe has native methods for them */                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  do_signature(getByte_raw_signature,     "(J)B")                                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  do_signature(putByte_raw_signature,     "(JB)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  do_signature(getShort_raw_signature,    "(J)S")                                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  do_signature(putShort_raw_signature,    "(JS)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  do_signature(getChar_raw_signature,     "(J)C")                                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  do_signature(putChar_raw_signature,     "(JC)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  do_signature(putInt_raw_signature,      "(JI)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
      do_alias(getLong_raw_signature,    /*(J)J*/ long_long_signature)                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
      do_alias(putLong_raw_signature,    /*(JJ)V*/ long_long_void_signature)                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  do_signature(getFloat_raw_signature,    "(J)F")                                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  do_signature(putFloat_raw_signature,    "(JF)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
      do_alias(getDouble_raw_signature,  /*(J)D*/ long_double_signature)                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  do_signature(putDouble_raw_signature,   "(JD)V")                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
      do_alias(getAddress_raw_signature, /*(J)J*/ long_long_signature)                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
      do_alias(putAddress_raw_signature, /*(JJ)V*/ long_long_void_signature)                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
   do_name(    getAddress_name,           "getAddress")                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
   do_name(    putAddress_name,           "putAddress")                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  do_intrinsic(_getByte_raw,              sun_misc_Unsafe,        getByte_name, getByte_raw_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  do_intrinsic(_getShort_raw,             sun_misc_Unsafe,        getShort_name, getShort_raw_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  do_intrinsic(_getChar_raw,              sun_misc_Unsafe,        getChar_name, getChar_raw_signature,           F_RN)  \
2255
54abdf3e1055 6378821: bitCount() should use POPC on SPARC processors and AMD+10h
twisti
parents: 1890
diff changeset
   838
  do_intrinsic(_getInt_raw,               sun_misc_Unsafe,        getInt_name, long_int_signature,               F_RN)  \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  do_intrinsic(_getLong_raw,              sun_misc_Unsafe,        getLong_name, getLong_raw_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  do_intrinsic(_getFloat_raw,             sun_misc_Unsafe,        getFloat_name, getFloat_raw_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  do_intrinsic(_getDouble_raw,            sun_misc_Unsafe,        getDouble_name, getDouble_raw_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  do_intrinsic(_getAddress_raw,           sun_misc_Unsafe,        getAddress_name, getAddress_raw_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  do_intrinsic(_putByte_raw,              sun_misc_Unsafe,        putByte_name, putByte_raw_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  do_intrinsic(_putShort_raw,             sun_misc_Unsafe,        putShort_name, putShort_raw_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  do_intrinsic(_putChar_raw,              sun_misc_Unsafe,        putChar_name, putChar_raw_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  do_intrinsic(_putInt_raw,               sun_misc_Unsafe,        putInt_name, putInt_raw_signature,             F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  do_intrinsic(_putLong_raw,              sun_misc_Unsafe,        putLong_name, putLong_raw_signature,           F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  do_intrinsic(_putFloat_raw,             sun_misc_Unsafe,        putFloat_name, putFloat_raw_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  do_intrinsic(_putDouble_raw,            sun_misc_Unsafe,        putDouble_name, putDouble_raw_signature,       F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  do_intrinsic(_putAddress_raw,           sun_misc_Unsafe,        putAddress_name, putAddress_raw_signature,     F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  do_intrinsic(_compareAndSwapObject,     sun_misc_Unsafe,        compareAndSwapObject_name, compareAndSwapObject_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
   do_name(     compareAndSwapObject_name,                       "compareAndSwapObject")                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
   do_signature(compareAndSwapObject_signature,  "(Ljava/lang/Object;JLjava/lang/Object;Ljava/lang/Object;)Z")          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  do_intrinsic(_compareAndSwapLong,       sun_misc_Unsafe,        compareAndSwapLong_name, compareAndSwapLong_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
   do_name(     compareAndSwapLong_name,                         "compareAndSwapLong")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
   do_signature(compareAndSwapLong_signature,                    "(Ljava/lang/Object;JJJ)Z")                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  do_intrinsic(_compareAndSwapInt,        sun_misc_Unsafe,        compareAndSwapInt_name, compareAndSwapInt_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
   do_name(     compareAndSwapInt_name,                          "compareAndSwapInt")                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
   do_signature(compareAndSwapInt_signature,                     "(Ljava/lang/Object;JII)Z")                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  do_intrinsic(_putOrderedObject,         sun_misc_Unsafe,        putOrderedObject_name, putOrderedObject_signature, F_RN) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
   do_name(     putOrderedObject_name,                           "putOrderedObject")                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
   do_alias(    putOrderedObject_signature,                     /*(LObject;JLObject;)V*/ putObject_signature)           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  do_intrinsic(_putOrderedLong,           sun_misc_Unsafe,        putOrderedLong_name, putOrderedLong_signature, F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
   do_name(     putOrderedLong_name,                             "putOrderedLong")                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
   do_alias(    putOrderedLong_signature,                       /*(Ljava/lang/Object;JJ)V*/ putLong_signature)          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  do_intrinsic(_putOrderedInt,            sun_misc_Unsafe,        putOrderedInt_name, putOrderedInt_signature,   F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
   do_name(     putOrderedInt_name,                              "putOrderedInt")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
   do_alias(    putOrderedInt_signature,                        /*(Ljava/lang/Object;JI)V*/ putInt_signature)           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  /* prefetch_signature is shared by all prefetch variants */                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  do_signature( prefetch_signature,        "(Ljava/lang/Object;J)V")                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
                                                                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  do_intrinsic(_prefetchRead,             sun_misc_Unsafe,        prefetchRead_name, prefetch_signature,         F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
   do_name(     prefetchRead_name,                               "prefetchRead")                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  do_intrinsic(_prefetchWrite,            sun_misc_Unsafe,        prefetchWrite_name, prefetch_signature,        F_RN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
   do_name(     prefetchWrite_name,                              "prefetchWrite")                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  do_intrinsic(_prefetchReadStatic,       sun_misc_Unsafe,        prefetchReadStatic_name, prefetch_signature,   F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
   do_name(     prefetchReadStatic_name,                         "prefetchReadStatic")                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  do_intrinsic(_prefetchWriteStatic,      sun_misc_Unsafe,        prefetchWriteStatic_name, prefetch_signature,  F_SN)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
   do_name(     prefetchWriteStatic_name,                        "prefetchWriteStatic")                                 \
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   882
    /*== LAST_COMPILER_INLINE*/                                                                                         \
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   883
    /*the compiler does have special inlining code for these; bytecode inline is just fine */                           \
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   884
                                                                                                                        \
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   885
  do_intrinsic(_fillInStackTrace,         java_lang_Throwable, fillInStackTrace_name, void_throwable_signature,  F_RNY) \
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   886
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   887
  do_intrinsic(_StringBuilder_void,   java_lang_StringBuilder, object_initializer_name, void_method_signature,     F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   888
  do_intrinsic(_StringBuilder_int,    java_lang_StringBuilder, object_initializer_name, int_void_signature,        F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   889
  do_intrinsic(_StringBuilder_String, java_lang_StringBuilder, object_initializer_name, string_void_signature,     F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   890
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   891
  do_intrinsic(_StringBuilder_append_char,   java_lang_StringBuilder, append_name, char_StringBuilder_signature,   F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   892
  do_intrinsic(_StringBuilder_append_int,    java_lang_StringBuilder, append_name, int_StringBuilder_signature,    F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   893
  do_intrinsic(_StringBuilder_append_String, java_lang_StringBuilder, append_name, String_StringBuilder_signature, F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   894
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   895
  do_intrinsic(_StringBuilder_toString, java_lang_StringBuilder, toString_name, void_string_signature,             F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   896
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   897
  do_intrinsic(_StringBuffer_void,   java_lang_StringBuffer, object_initializer_name, void_method_signature,       F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   898
  do_intrinsic(_StringBuffer_int,    java_lang_StringBuffer, object_initializer_name, int_void_signature,          F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   899
  do_intrinsic(_StringBuffer_String, java_lang_StringBuffer, object_initializer_name, string_void_signature,       F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   900
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   901
  do_intrinsic(_StringBuffer_append_char,   java_lang_StringBuffer, append_name, char_StringBuffer_signature,      F_Y)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   902
  do_intrinsic(_StringBuffer_append_int,    java_lang_StringBuffer, append_name, int_StringBuffer_signature,       F_Y)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   903
  do_intrinsic(_StringBuffer_append_String, java_lang_StringBuffer, append_name, String_StringBuffer_signature,    F_Y)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   904
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   905
  do_intrinsic(_StringBuffer_toString,  java_lang_StringBuffer, toString_name, void_string_signature,              F_Y)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   906
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   907
  do_intrinsic(_Integer_toString,      java_lang_Integer, toString_name, int_String_signature,                     F_S)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   908
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   909
  do_intrinsic(_String_String, java_lang_String, object_initializer_name, string_void_signature,                   F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   910
                                                                                                                          \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   911
  do_intrinsic(_Object_init,              java_lang_Object, object_initializer_name, void_method_signature,        F_R)   \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   912
  /*    (symbol object_initializer_name defined above) */                                                                 \
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
   913
                                                                                                                          \
5420
586d3988e72b 6939134: JSR 292 adjustments to method handle invocation
jrose
parents: 5352
diff changeset
   914
  do_intrinsic(_invoke,                   java_lang_reflect_Method, invoke_name, object_object_array_object_signature, F_R) \
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   915
  /*   (symbols invoke_name and invoke_signature defined above) */                                                      \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   916
  do_intrinsic(_checkSpreadArgument,      java_lang_invoke_MethodHandleNatives, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   917
  do_intrinsic(_checkSpreadArgument_TRANS,sun_dyn_MethodHandleImpl, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) /* AllowTransitionalJSR292 ONLY */ \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   918
  do_intrinsic(_checkSpreadArgument_TRANS2,java_dyn_MethodHandleNatives, checkSpreadArgument_name, checkSpreadArgument_signature, F_S) /* AllowTransitionalJSR292 ONLY */ \
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   919
   do_name(    checkSpreadArgument_name,       "checkSpreadArgument")                                                   \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   920
   do_name(    checkSpreadArgument_signature,  "(Ljava/lang/Object;I)V")                                                \
8676
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   921
  do_intrinsic(_invokeExact,              java_lang_invoke_MethodHandle, invokeExact_name,   object_array_object_signature, F_RN) \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   922
  do_intrinsic(_invokeGeneric,            java_lang_invoke_MethodHandle, invokeGeneric_name, object_array_object_signature, F_RN) \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   923
  do_intrinsic(_invokeVarargs,            java_lang_invoke_MethodHandle, invokeVarargs_name, object_array_object_signature, F_R)  \
9098d4e927e1 7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents: 8675
diff changeset
   924
  do_intrinsic(_invokeDynamic,            java_lang_invoke_InvokeDynamic, star_name,         object_array_object_signature, F_SN) \
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   925
                                                                                                                        \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   926
  /* unboxing methods: */                                                                                               \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   927
  do_intrinsic(_booleanValue,             java_lang_Boolean,      booleanValue_name, void_boolean_signature, F_R)       \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   928
   do_name(     booleanValue_name,       "booleanValue")                                                                \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   929
  do_intrinsic(_byteValue,                java_lang_Byte,         byteValue_name, void_byte_signature, F_R)             \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   930
   do_name(     byteValue_name,          "byteValue")                                                                   \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   931
  do_intrinsic(_charValue,                java_lang_Character,    charValue_name, void_char_signature, F_R)             \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   932
   do_name(     charValue_name,          "charValue")                                                                   \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   933
  do_intrinsic(_shortValue,               java_lang_Short,        shortValue_name, void_short_signature, F_R)           \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   934
   do_name(     shortValue_name,         "shortValue")                                                                  \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   935
  do_intrinsic(_intValue,                 java_lang_Integer,      intValue_name, void_int_signature, F_R)               \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   936
   do_name(     intValue_name,           "intValue")                                                                    \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   937
  do_intrinsic(_longValue,                java_lang_Long,         longValue_name, void_long_signature, F_R)             \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   938
   do_name(     longValue_name,          "longValue")                                                                   \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   939
  do_intrinsic(_floatValue,               java_lang_Float,        floatValue_name, void_float_signature, F_R)           \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   940
   do_name(     floatValue_name,         "floatValue")                                                                  \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   941
  do_intrinsic(_doubleValue,              java_lang_Double,       doubleValue_name, void_double_signature, F_R)         \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   942
   do_name(     doubleValue_name,        "doubleValue")                                                                 \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   943
                                                                                                                        \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   944
  /* boxing methods: */                                                                                                 \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   945
   do_name(    valueOf_name,              "valueOf")                                                                    \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   946
  do_intrinsic(_Boolean_valueOf,          java_lang_Boolean,      valueOf_name, Boolean_valueOf_signature, F_S)         \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   947
   do_name(     Boolean_valueOf_signature,                       "(Z)Ljava/lang/Boolean;")                              \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   948
  do_intrinsic(_Byte_valueOf,             java_lang_Byte,         valueOf_name, Byte_valueOf_signature, F_S)            \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   949
   do_name(     Byte_valueOf_signature,                          "(B)Ljava/lang/Byte;")                                 \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   950
  do_intrinsic(_Character_valueOf,        java_lang_Character,    valueOf_name, Character_valueOf_signature, F_S)       \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   951
   do_name(     Character_valueOf_signature,                     "(C)Ljava/lang/Character;")                            \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   952
  do_intrinsic(_Short_valueOf,            java_lang_Short,        valueOf_name, Short_valueOf_signature, F_S)           \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   953
   do_name(     Short_valueOf_signature,                         "(S)Ljava/lang/Short;")                                \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   954
  do_intrinsic(_Integer_valueOf,          java_lang_Integer,      valueOf_name, Integer_valueOf_signature, F_S)         \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   955
   do_name(     Integer_valueOf_signature,                       "(I)Ljava/lang/Integer;")                              \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   956
  do_intrinsic(_Long_valueOf,             java_lang_Long,         valueOf_name, Long_valueOf_signature, F_S)            \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   957
   do_name(     Long_valueOf_signature,                          "(J)Ljava/lang/Long;")                                 \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   958
  do_intrinsic(_Float_valueOf,            java_lang_Float,        valueOf_name, Float_valueOf_signature, F_S)           \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   959
   do_name(     Float_valueOf_signature,                         "(F)Ljava/lang/Float;")                                \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   960
  do_intrinsic(_Double_valueOf,           java_lang_Double,       valueOf_name, Double_valueOf_signature, F_S)          \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   961
   do_name(     Double_valueOf_signature,                        "(D)Ljava/lang/Double;")                               \
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   962
                                                                                                                        \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
    /*end*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
   967
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
// Class vmSymbols
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
class vmSymbols: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
 friend class vmIntrinsics;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
   973
  // enum for figuring positions and size of array holding Symbol*s
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  enum SID {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
    NO_SID = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
    #define VM_SYMBOL_ENUM(name, string) VM_SYMBOL_ENUM_NAME(name),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    VM_SYMBOLS_DO(VM_SYMBOL_ENUM, VM_ALIAS_IGNORE)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    #undef VM_SYMBOL_ENUM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
    SID_LIMIT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    #define VM_ALIAS_ENUM(name, def) VM_SYMBOL_ENUM_NAME(name) = VM_SYMBOL_ENUM_NAME(def),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    VM_SYMBOLS_DO(VM_SYMBOL_IGNORE, VM_ALIAS_ENUM)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    #undef VM_ALIAS_ENUM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    FIRST_SID = NO_SID + 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
    log2_SID_LIMIT = 10         // checked by an assert at start-up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  // The symbol array
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
   995
  static Symbol* _symbols[];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  // Field signatures indexed by BasicType.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
   998
  static Symbol* _type_signatures[T_VOID+1];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  // Initialization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  static void initialize(TRAPS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  // Accessing
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1004
  #define VM_SYMBOL_DECLARE(name, ignore)                 \
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1005
    static Symbol* name() {                               \
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1006
      return _symbols[VM_SYMBOL_ENUM_NAME(name)];         \
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1007
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  VM_SYMBOLS_DO(VM_SYMBOL_DECLARE, VM_SYMBOL_DECLARE)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  #undef VM_SYMBOL_DECLARE
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1011
  // Sharing support
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1012
  static void symbols_do(SymbolClosure* f);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1013
  static void serialize(SerializeOopClosure* soc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1015
  static Symbol* type_signature(BasicType t) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
    assert((uint)t < T_VOID+1, "range check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
    assert(_type_signatures[t] != NULL, "domain check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
    return _type_signatures[t];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  // inverse of type_signature; returns T_OBJECT if s is not recognized
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1021
  static BasicType signature_type(Symbol* s);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1023
  static Symbol* symbol_at(SID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
    assert(id >= FIRST_SID && id < SID_LIMIT, "oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
    assert(_symbols[id] != NULL, "init");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
    return _symbols[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  // Returns symbol's SID if one is assigned, else NO_SID.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7900
diff changeset
  1030
  static SID find_sid(Symbol* symbol);
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8117
diff changeset
  1031
  static SID find_sid(const char* symbol_name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  // No need for this in the product:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  static const char* name_for(SID sid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// VM Intrinsic ID's uniquely identify some very special methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
class vmIntrinsics: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  friend class vmSymbols;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  friend class ciObjectFactory;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  // Accessing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  enum ID {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
    _none = 0,                      // not an intrinsic (default answer)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
    #define VM_INTRINSIC_ENUM(id, klass, name, sig, flags)  id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
    VM_INTRINSICS_DO(VM_INTRINSIC_ENUM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
                     VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
    #undef VM_INTRINSIC_ENUM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
    ID_LIMIT,
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
  1055
    LAST_COMPILER_INLINE = _prefetchWriteStatic,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
    FIRST_ID = _none + 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  enum Flags {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
    // AccessFlags syndromes relevant to intrinsics.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
    F_none = 0,
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
  1062
    F_R,                        // !static ?native !synchronized (R="regular")
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
  1063
    F_S,                        //  static ?native !synchronized
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
  1064
    F_Y,                        // !static ?native  synchronized
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
  1065
    F_RN,                       // !static  native !synchronized
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 4429
diff changeset
  1066
    F_SN,                       //  static  native !synchronized
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1067
    F_RNY,                      // !static  native  synchronized
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1068
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1069
    FLAG_LIMIT
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1070
  };
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1071
  enum {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1072
    log2_FLAG_LIMIT = 4         // checked by an assert at start-up
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  static ID ID_from(int raw_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
    assert(raw_id >= (int)_none && raw_id < (int)ID_LIMIT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
           "must be a valid intrinsic ID");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
    return (ID)raw_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  static const char* name_at(ID id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1084
private:
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1085
  static ID find_id_impl(vmSymbols::SID holder,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1086
                         vmSymbols::SID name,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1087
                         vmSymbols::SID sig,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1088
                         jshort flags);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1089
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1090
public:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  // Given a method's class, name, signature, and access flags, report its ID.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  static ID find_id(vmSymbols::SID holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
                    vmSymbols::SID name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
                    vmSymbols::SID sig,
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1095
                    jshort flags) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1096
    ID id = find_id_impl(holder, name, sig, flags);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1097
#ifdef ASSERT
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1098
    // ID _none does not hold the following asserts.
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1099
    if (id == _none)  return id;
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1100
#endif
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1101
    assert(    class_for(id) == holder, "correct id");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1102
    assert(     name_for(id) == name,   "correct id");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1103
    assert(signature_for(id) == sig,    "correct id");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1104
    return id;
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1105
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  static void verify_method(ID actual_id, methodOop m) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1109
  // Find out the symbols behind an intrinsic:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  static vmSymbols::SID     class_for(ID id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
  static vmSymbols::SID      name_for(ID id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  static vmSymbols::SID signature_for(ID id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  static Flags              flags_for(ID id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  static const char* short_name_as_C_string(ID id, char* buf, int size);
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
  1116
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
  1117
  // Access to intrinsic methods:
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2862
diff changeset
  1118
  static methodOop method_for(ID id);
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1119
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1120
  // Wrapper object methods:
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1121
  static ID for_boxing(BasicType type);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
  1122
  static ID for_unboxing(BasicType type);
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4564
diff changeset
  1123
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4564
diff changeset
  1124
  // Raw conversion:
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4564
diff changeset
  1125
  static ID for_raw_conversion(BasicType src, BasicType dest);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
  1127
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6463
diff changeset
  1128
#endif // SHARE_VM_CLASSFILE_VMSYMBOLS_HPP