hotspot/src/share/vm/classfile/vmSymbols.cpp
author iklam
Wed, 02 Aug 2017 18:06:38 -0700
changeset 46746 ea379ebb9447
parent 46663 715d5f268f62
permissions -rw-r--r--
8072061: Automatically determine optimal sizes for the CDS regions Summary: See new C++ class MetaspaceClosure. Reviewed-by: coleenp, jiangli, mseledtsov
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
45514
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
     2
 * Copyright (c) 1997, 2017, 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: 4567
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4567
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: 4567
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: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "classfile/vmSymbols.hpp"
38699
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
    27
#include "compiler/compilerDirectives.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "memory/oopFactory.hpp"
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
    29
#include "memory/metaspaceClosure.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "oops/oop.inline.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 45514
diff changeset
    31
#include "prims/jvm.h"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "utilities/xmlstream.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    36
Symbol* vmSymbols::_symbols[vmSymbols::SID_LIMIT];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    38
Symbol* vmSymbols::_type_signatures[T_VOID+1] = { NULL /*, NULL...*/ };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33638
diff changeset
    40
inline int compare_symbol(const Symbol* a, const Symbol* b) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  if (a == b)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  // follow the natural address order:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  return (address)a > (address)b ? +1 : -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
static vmSymbols::SID vm_symbol_index[vmSymbols::SID_LIMIT];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  static int compare_vmsymbol_sid(const void* void_a, const void* void_b) {
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33638
diff changeset
    49
    const Symbol* a = vmSymbols::symbol_at(*((vmSymbols::SID*) void_a));
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33638
diff changeset
    50
    const Symbol* b = vmSymbols::symbol_at(*((vmSymbols::SID*) void_b));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    return compare_symbol(a, b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
17379
fec16b38217a 8012292: optimized build with GCC broken
roland
parents: 14391
diff changeset
    55
#ifdef ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
#define VM_SYMBOL_ENUM_NAME_BODY(name, string) #name "\0"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
static const char* vm_symbol_enum_names =
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  VM_SYMBOLS_DO(VM_SYMBOL_ENUM_NAME_BODY, VM_ALIAS_IGNORE)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  "\0";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
static const char* vm_symbol_enum_name(vmSymbols::SID sid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  const char* string = &vm_symbol_enum_names[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  int skip = (int)sid - (int)vmSymbols::FIRST_SID;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  for (; skip != 0; skip--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
    size_t skiplen = strlen(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    if (skiplen == 0)  return "<unknown>";  // overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    string += skiplen+1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  return string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
}
17379
fec16b38217a 8012292: optimized build with GCC broken
roland
parents: 14391
diff changeset
    70
#endif //ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// Put all the VM symbol strings in one place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// Makes for a more compact libjvm.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
#define VM_SYMBOL_BODY(name, string) string "\0"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
static const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
void vmSymbols::initialize(TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
    80
  assert(vmIntrinsics::FLAG_LIMIT <= (1 << vmIntrinsics::log2_FLAG_LIMIT), "must fit in this bitfield");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  if (!UseSharedSpaces) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    const char* string = &vm_symbol_bodies[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
12263
d20640f4f8fe 7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents: 8675
diff changeset
    85
      Symbol* sym = SymbolTable::new_permanent_symbol(string, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
      _symbols[index] = sym;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
      string += strlen(string); // skip string body
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
      string += 1;              // skip trailing null
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    _type_signatures[T_BYTE]    = byte_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    _type_signatures[T_CHAR]    = char_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    _type_signatures[T_DOUBLE]  = double_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    _type_signatures[T_FLOAT]   = float_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    _type_signatures[T_INT]     = int_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    _type_signatures[T_LONG]    = long_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    _type_signatures[T_SHORT]   = short_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    _type_signatures[T_BOOLEAN] = bool_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    _type_signatures[T_VOID]    = void_signature();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    // no single signatures for T_OBJECT or T_ARRAY
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // Check for duplicates:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  for (int i1 = (int)FIRST_SID; i1 < (int)SID_LIMIT; i1++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   106
    Symbol* sym = symbol_at((SID)i1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    for (int i2 = (int)FIRST_SID; i2 < i1; i2++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
      if (symbol_at((SID)i2) == sym) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
        tty->print("*** Duplicate VM symbol SIDs %s(%d) and %s(%d): \"",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
                   vm_symbol_enum_name((SID)i2), i2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
                   vm_symbol_enum_name((SID)i1), i1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
        sym->print_symbol_on(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
        tty->print_cr("\"");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
#endif //ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // Create an index for find_id:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      vm_symbol_index[index] = (SID)index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    int num_sids = SID_LIMIT-FIRST_SID;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    qsort(&vm_symbol_index[FIRST_SID], num_sids, sizeof(vm_symbol_index[0]),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
          compare_vmsymbol_sid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    // Spot-check correspondence between strings, symbols, and enums:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    assert(_symbols[NO_SID] == NULL, "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    const char* str = "java/lang/Object";
12263
d20640f4f8fe 7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents: 8675
diff changeset
   134
    TempNewSymbol jlo = SymbolTable::new_permanent_symbol(str, CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   135
    assert(strncmp(str, (char*)jlo->base(), jlo->utf8_length()) == 0, "");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   136
    assert(jlo == java_lang_Object(), "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    SID sid = VM_SYMBOL_ENUM_NAME(java_lang_Object);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   138
    assert(find_sid(jlo) == sid, "");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   139
    assert(symbol_at(sid) == jlo, "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    // Make sure find_sid produces the right answer in each case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   143
      Symbol* sym = symbol_at((SID)index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
      sid = find_sid(sym);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      assert(sid == (SID)index, "symbol index works");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
      // Note:  If there are duplicates, this assert will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
      // A "Duplicate VM symbol" message will have already been printed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    // The string "format" happens (at the moment) not to be a vmSymbol,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    // though it is a method name in java.lang.String.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    str = "format";
12263
d20640f4f8fe 7150058: Allocate symbols from null boot loader to an arena for NMT
coleenp
parents: 8675
diff changeset
   153
    TempNewSymbol fmt = SymbolTable::new_permanent_symbol(str, CHECK);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   154
    sid = find_sid(fmt);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    assert(sid == NO_SID, "symbol index works (negative test)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
const char* vmSymbols::name_for(vmSymbols::SID sid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  if (sid == NO_SID)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    return "NO_SID";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  const char* string = &vm_symbol_bodies[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    if (index == (int)sid)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
      return string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    string += strlen(string); // skip string body
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    string += 1;              // skip trailing null
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  return "BAD_SID";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   178
void vmSymbols::symbols_do(SymbolClosure* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   180
    f->do_symbol(&_symbols[index]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  for (int i = 0; i < T_VOID+1; i++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   183
    f->do_symbol(&_type_signatures[i]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
46746
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   187
void vmSymbols::metaspace_pointers_do(MetaspaceClosure *it) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   188
  for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   189
    it->push(&_symbols[index]);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   190
  }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   191
  for (int i = 0; i < T_VOID+1; i++) {
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   192
    it->push(&_type_signatures[i]);
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   193
  }
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   194
}
ea379ebb9447 8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents: 46663
diff changeset
   195
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   196
void vmSymbols::serialize(SerializeClosure* soc) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   197
  soc->do_region((u_char*)&_symbols[FIRST_SID],
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   198
                 (SID_LIMIT - FIRST_SID) * sizeof(_symbols[0]));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   199
  soc->do_region((u_char*)_type_signatures, sizeof(_type_signatures));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   200
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   202
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33638
diff changeset
   203
BasicType vmSymbols::signature_type(const Symbol* s) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  assert(s != NULL, "checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    if (s == _type_signatures[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
      return (BasicType)i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  return T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
static int mid_hint = (int)vmSymbols::FIRST_SID+1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
static int find_sid_calls, find_sid_probes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
// (Typical counts are calls=7000 and probes=17000.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 33638
diff changeset
   221
vmSymbols::SID vmSymbols::find_sid(const Symbol* symbol) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // Handle the majority of misses by a bounds check.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // Then, use a binary search over the index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  // Expected trip count is less than log2_SID_LIMIT, about eight.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  // This is slow but acceptable, given that calls are not
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   226
  // dynamically common.  (Method*::intrinsic_id has a cache.)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  NOT_PRODUCT(find_sid_calls++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  int min = (int)FIRST_SID, max = (int)SID_LIMIT - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  SID sid = NO_SID, sid1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  int cmp1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  sid1 = vm_symbol_index[min];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  cmp1 = compare_symbol(symbol, symbol_at(sid1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  if (cmp1 <= 0) {              // before the first
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    if (cmp1 == 0)  sid = sid1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    sid1 = vm_symbol_index[max];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    cmp1 = compare_symbol(symbol, symbol_at(sid1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    if (cmp1 >= 0) {            // after the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
      if (cmp1 == 0)  sid = sid1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      // After checking the extremes, do a binary search.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
      ++min; --max;             // endpoints are done
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
      int mid = mid_hint;       // start at previous success
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
      while (max >= min) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
        assert(mid >= min && mid <= max, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
        NOT_PRODUCT(find_sid_probes++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
        sid1 = vm_symbol_index[mid];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
        cmp1 = compare_symbol(symbol, symbol_at(sid1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
        if (cmp1 == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
          mid_hint = mid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
          sid = sid1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
        if (cmp1 < 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
          max = mid - 1;        // symbol < symbol_at(sid)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
          min = mid + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
        // Pick a new probe point:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
        mid = (max + min) / 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // Perform the exhaustive self-check the first 1000 calls,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // and every 100 calls thereafter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  static int find_sid_check_count = -2000;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  if ((uint)++find_sid_check_count > (uint)100) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    if (find_sid_check_count > 0)  find_sid_check_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    // Make sure this is the right answer, using linear search.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    // (We have already proven that there are no duplicates in the list.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    SID sid2 = NO_SID;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   276
      Symbol* sym2 = symbol_at((SID)index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
      if (sym2 == symbol) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
        sid2 = (SID)index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    // Unless it's a duplicate, assert that the sids are the same.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    if (_symbols[sid] != _symbols[sid2]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      assert(sid == sid2, "binary same as linear search");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
#endif //ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  return sid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
8675
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   292
vmSymbols::SID vmSymbols::find_sid(const char* symbol_name) {
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   293
  Symbol* symbol = SymbolTable::probe(symbol_name, (int) strlen(symbol_name));
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   294
  if (symbol == NULL)  return NO_SID;
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   295
  return find_sid(symbol);
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   296
}
e9fef2a9bef7 6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents: 8076
diff changeset
   297
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   298
static vmIntrinsics::ID wrapper_intrinsic(BasicType type, bool unboxing) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   299
#define TYPE2(type, unboxing) ((int)(type)*2 + ((unboxing) ? 1 : 0))
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   300
  switch (TYPE2(type, unboxing)) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   301
#define BASIC_TYPE_CASE(type, box, unbox) \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   302
    case TYPE2(type, false):  return vmIntrinsics::box; \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   303
    case TYPE2(type, true):   return vmIntrinsics::unbox
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   304
    BASIC_TYPE_CASE(T_BOOLEAN, _Boolean_valueOf,   _booleanValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   305
    BASIC_TYPE_CASE(T_BYTE,    _Byte_valueOf,      _byteValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   306
    BASIC_TYPE_CASE(T_CHAR,    _Character_valueOf, _charValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   307
    BASIC_TYPE_CASE(T_SHORT,   _Short_valueOf,     _shortValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   308
    BASIC_TYPE_CASE(T_INT,     _Integer_valueOf,   _intValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   309
    BASIC_TYPE_CASE(T_LONG,    _Long_valueOf,      _longValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   310
    BASIC_TYPE_CASE(T_FLOAT,   _Float_valueOf,     _floatValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   311
    BASIC_TYPE_CASE(T_DOUBLE,  _Double_valueOf,    _doubleValue);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   312
#undef BASIC_TYPE_CASE
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   313
  }
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   314
#undef TYPE2
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   315
  return vmIntrinsics::_none;
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   316
}
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   317
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   318
vmIntrinsics::ID vmIntrinsics::for_boxing(BasicType type) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   319
  return wrapper_intrinsic(type, false);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   320
}
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   321
vmIntrinsics::ID vmIntrinsics::for_unboxing(BasicType type) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   322
  return wrapper_intrinsic(type, true);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   323
}
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   324
4567
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   325
vmIntrinsics::ID vmIntrinsics::for_raw_conversion(BasicType src, BasicType dest) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   326
#define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   327
  switch (SRC_DEST(src, dest)) {
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   328
  case SRC_DEST(T_INT, T_FLOAT):   return vmIntrinsics::_intBitsToFloat;
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   329
  case SRC_DEST(T_FLOAT, T_INT):   return vmIntrinsics::_floatToRawIntBits;
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   330
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   331
  case SRC_DEST(T_LONG, T_DOUBLE): return vmIntrinsics::_longBitsToDouble;
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   332
  case SRC_DEST(T_DOUBLE, T_LONG): return vmIntrinsics::_doubleToRawLongBits;
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   333
  }
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   334
#undef SRC_DEST
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   335
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   336
  return vmIntrinsics::_none;
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   337
}
7fc02fbe5c7a 6893268: additional dynamic language related optimizations in C2
twisti
parents: 4562
diff changeset
   338
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   339
bool vmIntrinsics::preserves_state(vmIntrinsics::ID id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   340
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   341
  switch(id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   342
#ifdef TRACE_HAVE_INTRINSICS
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   343
  case vmIntrinsics::_counterTime:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   344
#endif
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   345
  case vmIntrinsics::_currentTimeMillis:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   346
  case vmIntrinsics::_nanoTime:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   347
  case vmIntrinsics::_floatToRawIntBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   348
  case vmIntrinsics::_intBitsToFloat:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   349
  case vmIntrinsics::_doubleToRawLongBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   350
  case vmIntrinsics::_longBitsToDouble:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   351
  case vmIntrinsics::_getClass:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   352
  case vmIntrinsics::_isInstance:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   353
  case vmIntrinsics::_currentThread:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   354
  case vmIntrinsics::_dabs:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   355
  case vmIntrinsics::_dsqrt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   356
  case vmIntrinsics::_dsin:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   357
  case vmIntrinsics::_dcos:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   358
  case vmIntrinsics::_dtan:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   359
  case vmIntrinsics::_dlog:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   360
  case vmIntrinsics::_dlog10:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   361
  case vmIntrinsics::_dexp:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   362
  case vmIntrinsics::_dpow:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   363
  case vmIntrinsics::_checkIndex:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   364
  case vmIntrinsics::_Reference_get:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   365
  case vmIntrinsics::_updateCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   366
  case vmIntrinsics::_updateBytesCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   367
  case vmIntrinsics::_updateByteBufferCRC32:
38238
1bbcc430c78d 8151268: Wire up the x86 _vectorizedMismatch stub routine in C1
psandoz
parents: 36827
diff changeset
   368
  case vmIntrinsics::_vectorizedMismatch:
41323
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   369
  case vmIntrinsics::_fmaD:
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   370
  case vmIntrinsics::_fmaF:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   371
    return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   372
  default:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   373
    return false;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   374
  }
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   375
}
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   376
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   377
bool vmIntrinsics::can_trap(vmIntrinsics::ID id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   378
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   379
  switch(id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   380
#ifdef TRACE_HAVE_INTRINSICS
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   381
  case vmIntrinsics::_counterTime:
40899
d7140c75c2c6 8163589: Add back class id intrinsic method for event based tracing
rehn
parents: 38699
diff changeset
   382
  case vmIntrinsics::_getClassId:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   383
#endif
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   384
  case vmIntrinsics::_currentTimeMillis:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   385
  case vmIntrinsics::_nanoTime:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   386
  case vmIntrinsics::_floatToRawIntBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   387
  case vmIntrinsics::_intBitsToFloat:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   388
  case vmIntrinsics::_doubleToRawLongBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   389
  case vmIntrinsics::_longBitsToDouble:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   390
  case vmIntrinsics::_currentThread:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   391
  case vmIntrinsics::_dabs:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   392
  case vmIntrinsics::_dsqrt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   393
  case vmIntrinsics::_dsin:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   394
  case vmIntrinsics::_dcos:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   395
  case vmIntrinsics::_dtan:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   396
  case vmIntrinsics::_dlog:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   397
  case vmIntrinsics::_dlog10:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   398
  case vmIntrinsics::_dexp:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   399
  case vmIntrinsics::_dpow:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   400
  case vmIntrinsics::_updateCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   401
  case vmIntrinsics::_updateBytesCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   402
  case vmIntrinsics::_updateByteBufferCRC32:
38238
1bbcc430c78d 8151268: Wire up the x86 _vectorizedMismatch stub routine in C1
psandoz
parents: 36827
diff changeset
   403
  case vmIntrinsics::_vectorizedMismatch:
41323
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   404
  case vmIntrinsics::_fmaD:
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   405
  case vmIntrinsics::_fmaF:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   406
    return false;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   407
  default:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   408
    return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   409
  }
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   410
}
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   411
46663
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   412
// Some intrinsics produce different results if they are not pinned
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   413
bool vmIntrinsics::should_be_pinned(vmIntrinsics::ID id) {
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   414
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   415
  switch(id) {
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   416
#ifdef TRACE_HAVE_INTRINSICS
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   417
  case vmIntrinsics::_counterTime:
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   418
#endif
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   419
  case vmIntrinsics::_currentTimeMillis:
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   420
  case vmIntrinsics::_nanoTime:
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   421
    return true;
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   422
  default:
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   423
    return false;
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   424
  }
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   425
}
715d5f268f62 8184271: Time related C1 intrinsics produce inconsistent results when floating around
thartmann
parents: 46630
diff changeset
   426
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   427
bool vmIntrinsics::does_virtual_dispatch(vmIntrinsics::ID id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   428
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   429
  switch(id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   430
  case vmIntrinsics::_hashCode:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   431
  case vmIntrinsics::_clone:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   432
    return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   433
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   434
  default:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   435
    return false;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   436
  }
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   437
}
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   438
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   439
int vmIntrinsics::predicates_needed(vmIntrinsics::ID id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   440
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   441
  switch (id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   442
  case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   443
  case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
35154
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35135
diff changeset
   444
  case vmIntrinsics::_counterMode_AESCrypt:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   445
    return 1;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   446
  case vmIntrinsics::_digestBase_implCompressMB:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   447
    return 3;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   448
  default:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   449
    return 0;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   450
  }
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   451
}
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   452
38699
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   453
bool vmIntrinsics::is_intrinsic_available(vmIntrinsics::ID id) {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   454
  return !vmIntrinsics::is_intrinsic_disabled(id) &&
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   455
    !vmIntrinsics::is_disabled_by_flags(id);
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   456
}
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   457
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   458
bool vmIntrinsics::is_intrinsic_disabled(vmIntrinsics::ID id) {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   459
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   460
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   461
  // Canonicalize DisableIntrinsic to contain only ',' as a separator.
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   462
  // Note, DirectiveSet may not be created at this point yet since this code
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   463
  // is called from initial stub geenration code.
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   464
  char* local_list = (char*)DirectiveSet::canonicalize_disableintrinsic(DisableIntrinsic);
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   465
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   466
  bool found = false;
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   467
  char* token = strtok(local_list, ",");
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   468
  while (token != NULL) {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   469
    if (strcmp(token, vmIntrinsics::name_at(id)) == 0) {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   470
      found = true;
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   471
      break;
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   472
    } else {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   473
      token = strtok(NULL, ",");
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   474
    }
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   475
  }
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   476
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   477
  FREE_C_HEAP_ARRAY(char, local_list);
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   478
  return found;
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   479
}
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   480
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   481
33626
jwilhelm
parents: 33593 33451
diff changeset
   482
bool vmIntrinsics::is_disabled_by_flags(const methodHandle& method) {
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   483
  vmIntrinsics::ID id = method->intrinsic_id();
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   484
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
38699
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   485
  return is_disabled_by_flags(id);
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   486
}
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   487
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   488
bool vmIntrinsics::is_disabled_by_flags(vmIntrinsics::ID id) {
f8bec5f6b09c 8154473: Update for CompilerDirectives to control stub generation and intrinsics
vdeshpande
parents: 38246
diff changeset
   489
  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   490
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   491
  // -XX:-InlineNatives disables nearly all intrinsics except the ones listed in
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   492
  // the following switch statement.
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   493
  if (!InlineNatives) {
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   494
    switch (id) {
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   495
    case vmIntrinsics::_indexOfL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   496
    case vmIntrinsics::_indexOfU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   497
    case vmIntrinsics::_indexOfUL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   498
    case vmIntrinsics::_indexOfIL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   499
    case vmIntrinsics::_indexOfIU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   500
    case vmIntrinsics::_indexOfIUL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   501
    case vmIntrinsics::_indexOfU_char:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   502
    case vmIntrinsics::_compareToL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   503
    case vmIntrinsics::_compareToU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   504
    case vmIntrinsics::_compareToLU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   505
    case vmIntrinsics::_compareToUL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   506
    case vmIntrinsics::_equalsL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   507
    case vmIntrinsics::_equalsU:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   508
    case vmIntrinsics::_equalsC:
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   509
    case vmIntrinsics::_getCharStringU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   510
    case vmIntrinsics::_putCharStringU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   511
    case vmIntrinsics::_compressStringC:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   512
    case vmIntrinsics::_compressStringB:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   513
    case vmIntrinsics::_inflateStringC:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   514
    case vmIntrinsics::_inflateStringB:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   515
    case vmIntrinsics::_getAndAddInt:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   516
    case vmIntrinsics::_getAndAddLong:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   517
    case vmIntrinsics::_getAndSetInt:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   518
    case vmIntrinsics::_getAndSetLong:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   519
    case vmIntrinsics::_getAndSetObject:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   520
    case vmIntrinsics::_loadFence:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   521
    case vmIntrinsics::_storeFence:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   522
    case vmIntrinsics::_fullFence:
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   523
    case vmIntrinsics::_hasNegatives:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   524
    case vmIntrinsics::_Reference_get:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   525
      break;
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   526
    default:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   527
      return true;
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   528
    }
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   529
  }
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   530
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   531
  switch (id) {
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   532
  case vmIntrinsics::_isInstance:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   533
  case vmIntrinsics::_isAssignableFrom:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   534
  case vmIntrinsics::_getModifiers:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   535
  case vmIntrinsics::_isInterface:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   536
  case vmIntrinsics::_isArray:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   537
  case vmIntrinsics::_isPrimitive:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   538
  case vmIntrinsics::_getSuperclass:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   539
  case vmIntrinsics::_Class_cast:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   540
  case vmIntrinsics::_getLength:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   541
  case vmIntrinsics::_newArray:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   542
  case vmIntrinsics::_getClass:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   543
    if (!InlineClassNatives) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   544
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   545
  case vmIntrinsics::_currentThread:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   546
  case vmIntrinsics::_isInterrupted:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   547
    if (!InlineThreadNatives) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   548
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   549
  case vmIntrinsics::_floatToRawIntBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   550
  case vmIntrinsics::_intBitsToFloat:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   551
  case vmIntrinsics::_doubleToRawLongBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   552
  case vmIntrinsics::_longBitsToDouble:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   553
  case vmIntrinsics::_dabs:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   554
  case vmIntrinsics::_dsqrt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   555
  case vmIntrinsics::_dsin:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   556
  case vmIntrinsics::_dcos:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   557
  case vmIntrinsics::_dtan:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   558
  case vmIntrinsics::_dlog:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   559
  case vmIntrinsics::_dexp:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   560
  case vmIntrinsics::_dpow:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   561
  case vmIntrinsics::_dlog10:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   562
  case vmIntrinsics::_datan2:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   563
  case vmIntrinsics::_min:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   564
  case vmIntrinsics::_max:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   565
  case vmIntrinsics::_floatToIntBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   566
  case vmIntrinsics::_doubleToLongBits:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   567
    if (!InlineMathNatives) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   568
    break;
41323
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   569
  case vmIntrinsics::_fmaD:
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   570
  case vmIntrinsics::_fmaF:
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   571
    if (!InlineMathNatives || !UseFMA) return true;
ddd5600d4762 8154122: Intrinsify fused mac operations
vdeshpande
parents: 38699
diff changeset
   572
    break;
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   573
  case vmIntrinsics::_arraycopy:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   574
    if (!InlineArrayCopy) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   575
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   576
  case vmIntrinsics::_updateCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   577
  case vmIntrinsics::_updateBytesCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   578
  case vmIntrinsics::_updateByteBufferCRC32:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   579
    if (!UseCRC32Intrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   580
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   581
  case vmIntrinsics::_getObject:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   582
  case vmIntrinsics::_getBoolean:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   583
  case vmIntrinsics::_getByte:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   584
  case vmIntrinsics::_getShort:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   585
  case vmIntrinsics::_getChar:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   586
  case vmIntrinsics::_getInt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   587
  case vmIntrinsics::_getLong:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   588
  case vmIntrinsics::_getFloat:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   589
  case vmIntrinsics::_getDouble:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   590
  case vmIntrinsics::_putObject:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   591
  case vmIntrinsics::_putBoolean:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   592
  case vmIntrinsics::_putByte:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   593
  case vmIntrinsics::_putShort:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   594
  case vmIntrinsics::_putChar:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   595
  case vmIntrinsics::_putInt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   596
  case vmIntrinsics::_putLong:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   597
  case vmIntrinsics::_putFloat:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   598
  case vmIntrinsics::_putDouble:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   599
  case vmIntrinsics::_getObjectVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   600
  case vmIntrinsics::_getBooleanVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   601
  case vmIntrinsics::_getByteVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   602
  case vmIntrinsics::_getShortVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   603
  case vmIntrinsics::_getCharVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   604
  case vmIntrinsics::_getIntVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   605
  case vmIntrinsics::_getLongVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   606
  case vmIntrinsics::_getFloatVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   607
  case vmIntrinsics::_getDoubleVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   608
  case vmIntrinsics::_putObjectVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   609
  case vmIntrinsics::_putBooleanVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   610
  case vmIntrinsics::_putByteVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   611
  case vmIntrinsics::_putShortVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   612
  case vmIntrinsics::_putCharVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   613
  case vmIntrinsics::_putIntVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   614
  case vmIntrinsics::_putLongVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   615
  case vmIntrinsics::_putFloatVolatile:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   616
  case vmIntrinsics::_putDoubleVolatile:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   617
  case vmIntrinsics::_getObjectAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   618
  case vmIntrinsics::_getBooleanAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   619
  case vmIntrinsics::_getByteAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   620
  case vmIntrinsics::_getShortAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   621
  case vmIntrinsics::_getCharAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   622
  case vmIntrinsics::_getIntAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   623
  case vmIntrinsics::_getLongAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   624
  case vmIntrinsics::_getFloatAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   625
  case vmIntrinsics::_getDoubleAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   626
  case vmIntrinsics::_putObjectRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   627
  case vmIntrinsics::_putBooleanRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   628
  case vmIntrinsics::_putByteRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   629
  case vmIntrinsics::_putShortRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   630
  case vmIntrinsics::_putCharRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   631
  case vmIntrinsics::_putIntRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   632
  case vmIntrinsics::_putLongRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   633
  case vmIntrinsics::_putFloatRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   634
  case vmIntrinsics::_putDoubleRelease:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   635
  case vmIntrinsics::_getObjectOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   636
  case vmIntrinsics::_getBooleanOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   637
  case vmIntrinsics::_getByteOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   638
  case vmIntrinsics::_getShortOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   639
  case vmIntrinsics::_getCharOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   640
  case vmIntrinsics::_getIntOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   641
  case vmIntrinsics::_getLongOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   642
  case vmIntrinsics::_getFloatOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   643
  case vmIntrinsics::_getDoubleOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   644
  case vmIntrinsics::_putObjectOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   645
  case vmIntrinsics::_putBooleanOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   646
  case vmIntrinsics::_putByteOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   647
  case vmIntrinsics::_putShortOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   648
  case vmIntrinsics::_putCharOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   649
  case vmIntrinsics::_putIntOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   650
  case vmIntrinsics::_putLongOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   651
  case vmIntrinsics::_putFloatOpaque:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   652
  case vmIntrinsics::_putDoubleOpaque:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   653
  case vmIntrinsics::_getAndAddInt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   654
  case vmIntrinsics::_getAndAddLong:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   655
  case vmIntrinsics::_getAndSetInt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   656
  case vmIntrinsics::_getAndSetLong:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   657
  case vmIntrinsics::_getAndSetObject:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   658
  case vmIntrinsics::_loadFence:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   659
  case vmIntrinsics::_storeFence:
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   660
  case vmIntrinsics::_fullFence:
45514
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   661
  case vmIntrinsics::_compareAndSetLong:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   662
  case vmIntrinsics::_weakCompareAndSetLong:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   663
  case vmIntrinsics::_weakCompareAndSetLongPlain:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   664
  case vmIntrinsics::_weakCompareAndSetLongAcquire:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   665
  case vmIntrinsics::_weakCompareAndSetLongRelease:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   666
  case vmIntrinsics::_compareAndSetInt:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   667
  case vmIntrinsics::_weakCompareAndSetInt:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   668
  case vmIntrinsics::_weakCompareAndSetIntPlain:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   669
  case vmIntrinsics::_weakCompareAndSetIntAcquire:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   670
  case vmIntrinsics::_weakCompareAndSetIntRelease:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   671
  case vmIntrinsics::_compareAndSetObject:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   672
  case vmIntrinsics::_weakCompareAndSetObject:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   673
  case vmIntrinsics::_weakCompareAndSetObjectPlain:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   674
  case vmIntrinsics::_weakCompareAndSetObjectAcquire:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   675
  case vmIntrinsics::_weakCompareAndSetObjectRelease:
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   676
  case vmIntrinsics::_compareAndExchangeInt:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   677
  case vmIntrinsics::_compareAndExchangeIntAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   678
  case vmIntrinsics::_compareAndExchangeIntRelease:
45514
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   679
  case vmIntrinsics::_compareAndExchangeLong:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   680
  case vmIntrinsics::_compareAndExchangeLongAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   681
  case vmIntrinsics::_compareAndExchangeLongRelease:
45514
0fc9cc73ce45 8181292: Backport Rename internal Unsafe.compare methods from 10 to 9
psandoz
parents: 41330
diff changeset
   682
  case vmIntrinsics::_compareAndExchangeObject:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   683
  case vmIntrinsics::_compareAndExchangeObjectAcquire:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 35154
diff changeset
   684
  case vmIntrinsics::_compareAndExchangeObjectRelease:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   685
    if (!InlineUnsafeOps) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   686
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   687
  case vmIntrinsics::_getShortUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   688
  case vmIntrinsics::_getCharUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   689
  case vmIntrinsics::_getIntUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   690
  case vmIntrinsics::_getLongUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   691
  case vmIntrinsics::_putShortUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   692
  case vmIntrinsics::_putCharUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   693
  case vmIntrinsics::_putIntUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   694
  case vmIntrinsics::_putLongUnaligned:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   695
  case vmIntrinsics::_allocateInstance:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   696
    if (!InlineUnsafeOps || !UseUnalignedAccesses) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   697
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   698
  case vmIntrinsics::_hashCode:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   699
    if (!InlineObjectHash) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   700
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   701
  case vmIntrinsics::_aescrypt_encryptBlock:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   702
  case vmIntrinsics::_aescrypt_decryptBlock:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   703
    if (!UseAESIntrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   704
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   705
  case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   706
  case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   707
    if (!UseAESIntrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   708
    break;
35154
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35135
diff changeset
   709
  case vmIntrinsics::_counterMode_AESCrypt:
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35135
diff changeset
   710
    if (!UseAESCTRIntrinsics) return true;
a9b3c1984a01 8143925: Enhancing CounterMode.crypt() for AES
kvn
parents: 35135
diff changeset
   711
    break;
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   712
  case vmIntrinsics::_sha_implCompress:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   713
    if (!UseSHA1Intrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   714
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   715
  case vmIntrinsics::_sha2_implCompress:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   716
    if (!UseSHA256Intrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   717
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   718
  case vmIntrinsics::_sha5_implCompress:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   719
    if (!UseSHA512Intrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   720
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   721
  case vmIntrinsics::_digestBase_implCompressMB:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   722
    if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   723
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   724
  case vmIntrinsics::_ghash_processBlocks:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   725
    if (!UseGHASHIntrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   726
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   727
  case vmIntrinsics::_updateBytesCRC32C:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   728
  case vmIntrinsics::_updateDirectByteBufferCRC32C:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   729
    if (!UseCRC32CIntrinsics) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   730
    break;
38238
1bbcc430c78d 8151268: Wire up the x86 _vectorizedMismatch stub routine in C1
psandoz
parents: 36827
diff changeset
   731
  case vmIntrinsics::_vectorizedMismatch:
1bbcc430c78d 8151268: Wire up the x86 _vectorizedMismatch stub routine in C1
psandoz
parents: 36827
diff changeset
   732
    if (!UseVectorizedMismatchIntrinsic) return true;
1bbcc430c78d 8151268: Wire up the x86 _vectorizedMismatch stub routine in C1
psandoz
parents: 36827
diff changeset
   733
    break;
32581
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 32085
diff changeset
   734
  case vmIntrinsics::_updateBytesAdler32:
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 32085
diff changeset
   735
  case vmIntrinsics::_updateByteBufferAdler32:
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 32085
diff changeset
   736
    if (!UseAdler32Intrinsics) return true;
632402f18fe6 8132081: C2 support for Adler32 on SPARC
kvn
parents: 32085
diff changeset
   737
    break;
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   738
  case vmIntrinsics::_copyMemory:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   739
    if (!InlineArrayCopy || !InlineUnsafeOps) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   740
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   741
#ifdef COMPILER1
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   742
  case vmIntrinsics::_checkIndex:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   743
    if (!InlineNIOCheckIndex) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   744
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   745
#endif // COMPILER1
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   746
#ifdef COMPILER2
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   747
  case vmIntrinsics::_clone:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   748
  case vmIntrinsics::_copyOf:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   749
  case vmIntrinsics::_copyOfRange:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   750
    // These intrinsics use both the objectcopy and the arraycopy
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   751
    // intrinsic mechanism.
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   752
    if (!InlineObjectCopy || !InlineArrayCopy) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   753
    break;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   754
  case vmIntrinsics::_compareToL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   755
  case vmIntrinsics::_compareToU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   756
  case vmIntrinsics::_compareToLU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   757
  case vmIntrinsics::_compareToUL:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   758
    if (!SpecialStringCompareTo) return true;
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   759
    break;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   760
  case vmIntrinsics::_indexOfL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   761
  case vmIntrinsics::_indexOfU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   762
  case vmIntrinsics::_indexOfUL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   763
  case vmIntrinsics::_indexOfIL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   764
  case vmIntrinsics::_indexOfIU:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   765
  case vmIntrinsics::_indexOfIUL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   766
  case vmIntrinsics::_indexOfU_char:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   767
    if (!SpecialStringIndexOf) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   768
    break;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   769
  case vmIntrinsics::_equalsL:
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   770
  case vmIntrinsics::_equalsU:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   771
    if (!SpecialStringEquals) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   772
    break;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   773
  case vmIntrinsics::_equalsB:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   774
  case vmIntrinsics::_equalsC:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   775
    if (!SpecialArraysEquals) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   776
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   777
  case vmIntrinsics::_encodeISOArray:
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33451
diff changeset
   778
  case vmIntrinsics::_encodeByteISOArray:
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   779
    if (!SpecialEncodeISOArray) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   780
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   781
  case vmIntrinsics::_getCallerClass:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   782
    if (!InlineReflectionGetCallerClass) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   783
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   784
  case vmIntrinsics::_multiplyToLen:
32085
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   785
    if (!UseMultiplyToLenIntrinsic) return true;
d869c505b624 8132457: Unify command-line flags controlling the usage of compiler intrinsics
zmajo
parents: 31962
diff changeset
   786
    break;
31962
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   787
  case vmIntrinsics::_squareToLen:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   788
    if (!UseSquareToLenIntrinsic) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   789
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   790
  case vmIntrinsics::_mulAdd:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   791
    if (!UseMulAddIntrinsic) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   792
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   793
  case vmIntrinsics::_montgomeryMultiply:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   794
    if (!UseMontgomeryMultiplyIntrinsic) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   795
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   796
  case vmIntrinsics::_montgomerySquare:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   797
    if (!UseMontgomerySquareIntrinsic) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   798
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   799
  case vmIntrinsics::_addExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   800
  case vmIntrinsics::_addExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   801
  case vmIntrinsics::_decrementExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   802
  case vmIntrinsics::_decrementExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   803
  case vmIntrinsics::_incrementExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   804
  case vmIntrinsics::_incrementExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   805
  case vmIntrinsics::_multiplyExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   806
  case vmIntrinsics::_multiplyExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   807
  case vmIntrinsics::_negateExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   808
  case vmIntrinsics::_negateExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   809
  case vmIntrinsics::_subtractExactI:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   810
  case vmIntrinsics::_subtractExactL:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   811
    if (!UseMathExactIntrinsics || !InlineMathNatives) return true;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   812
    break;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   813
#endif // COMPILER2
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   814
  default:
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   815
    return false;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   816
  }
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   817
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   818
  return false;
d05e0a4d1b43 8130832: Extend the WhiteBox API to provide information about the availability of compiler intrinsics
zmajo
parents: 24424
diff changeset
   819
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
#define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
static const char* vm_intrinsic_name_bodies =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
                   VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
static const char* vm_intrinsic_name_table[vmIntrinsics::ID_LIMIT];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
const char* vmIntrinsics::name_at(vmIntrinsics::ID id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  const char** nt = &vm_intrinsic_name_table[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  if (nt[_none] == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    char* string = (char*) &vm_intrinsic_name_bodies[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    for (int index = FIRST_ID; index < ID_LIMIT; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
      nt[index] = string;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
      string += strlen(string); // skip string body
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
      string += 1;              // skip trailing null
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
    assert(!strcmp(nt[_hashCode], "_hashCode"), "lined up");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
    nt[_none] = "_none";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  if ((uint)id < (uint)ID_LIMIT)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
    return vm_intrinsic_name_table[(uint)id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    return "(unknown intrinsic)";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
// These are flag-matching functions:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
inline bool match_F_R(jshort flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  const int req = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  return (flags & (req | neg)) == req;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
}
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   852
inline bool match_F_Y(jshort flags) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   853
  const int req = JVM_ACC_SYNCHRONIZED;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   854
  const int neg = JVM_ACC_STATIC;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   855
  return (flags & (req | neg)) == req;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   856
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
inline bool match_F_RN(jshort flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  const int req = JVM_ACC_NATIVE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  return (flags & (req | neg)) == req;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
inline bool match_F_S(jshort flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  const int req = JVM_ACC_STATIC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  const int neg = JVM_ACC_SYNCHRONIZED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  return (flags & (req | neg)) == req;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
inline bool match_F_SN(jshort flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  const int req = JVM_ACC_STATIC | JVM_ACC_NATIVE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  const int neg = JVM_ACC_SYNCHRONIZED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  return (flags & (req | neg)) == req;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
}
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   872
inline bool match_F_RNY(jshort flags) {
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   873
  const int req = JVM_ACC_NATIVE | JVM_ACC_SYNCHRONIZED;
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   874
  const int neg = JVM_ACC_STATIC;
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   875
  return (flags & (req | neg)) == req;
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   876
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
// These are for forming case labels:
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   879
#define ID3(x, y, z) (( jlong)(z) +                                  \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   880
                      ((jlong)(y) <<    vmSymbols::log2_SID_LIMIT) + \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   881
                      ((jlong)(x) << (2*vmSymbols::log2_SID_LIMIT))  )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
#define SID_ENUM(n) vmSymbols::VM_SYMBOL_ENUM_NAME(n)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   884
vmIntrinsics::ID vmIntrinsics::find_id_impl(vmSymbols::SID holder,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   885
                                            vmSymbols::SID name,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   886
                                            vmSymbols::SID sig,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   887
                                            jshort flags) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  assert((int)vmSymbols::SID_LIMIT <= (1<<vmSymbols::log2_SID_LIMIT), "must fit");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  // Let the C compiler build the decision tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
#define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  case ID3(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig)): \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
    if (!match_##fcode(flags))  break; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
    return id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  switch (ID3(holder, name, sig)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
    VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
                     VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  return vmIntrinsics::_none;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
#undef VM_INTRINSIC_CASE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
const char* vmIntrinsics::short_name_as_C_string(vmIntrinsics::ID id, char* buf, int buflen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  const char* str = name_at(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  const char* kname = vmSymbols::name_for(class_for(id));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  const char* mname = vmSymbols::name_for(name_for(id));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  const char* sname = vmSymbols::name_for(signature_for(id));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  const char* fname = "";
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  switch (flags_for(id)) {
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 670
diff changeset
   915
  case F_Y:  fname = "synchronized ";  break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  case F_RN: fname = "native ";        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  case F_SN: fname = "native static "; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  case F_S:  fname = "static ";        break;
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   919
  case F_RNY:fname = "native synchronized "; break;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46560
diff changeset
   920
  default:   break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  const char* kptr = strrchr(kname, '/');
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  if (kptr != NULL)  kname = kptr + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  int len = jio_snprintf(buf, buflen, "%s: %s%s.%s%s",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
                         str, fname, kname, mname, sname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  if (len < buflen)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
    str = buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  return str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   933
// These are to get information about intrinsics.
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   934
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   935
#define ID4(x, y, z, f) ((ID3(x, y, z) << vmIntrinsics::log2_FLAG_LIMIT) | (jlong) (f))
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   936
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   937
static const jlong intrinsic_info_array[vmIntrinsics::ID_LIMIT+1] = {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   938
#define VM_INTRINSIC_INFO(ignore_id, klass, name, sig, fcode) \
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   939
  ID4(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig), vmIntrinsics::fcode),
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   940
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   941
  0, VM_INTRINSICS_DO(VM_INTRINSIC_INFO,
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   942
                     VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   943
    0
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   944
#undef VM_INTRINSIC_INFO
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   945
};
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   946
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   947
inline jlong intrinsic_info(vmIntrinsics::ID id) {
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   948
  return intrinsic_info_array[vmIntrinsics::ID_from((int)id)];
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   949
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   952
  jlong info = intrinsic_info(id);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   953
  int shift = 2*vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   954
  assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1021, "");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   955
  return vmSymbols::SID( (info >> shift) & mask );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   959
  jlong info = intrinsic_info(id);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   960
  int shift = vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   961
  assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1022, "");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   962
  return vmSymbols::SID( (info >> shift) & mask );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   966
  jlong info = intrinsic_info(id);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   967
  int shift = log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   968
  assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1023, "");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   969
  return vmSymbols::SID( (info >> shift) & mask );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
4562
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   973
  jlong info = intrinsic_info(id);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   974
  int shift = 0, mask = right_n_bits(log2_FLAG_LIMIT);
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   975
  assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 15, "");
5d93cb2d2090 6894206: JVM needs a way to traverse method handle structures
twisti
parents: 4450
diff changeset
   976
  return Flags( (info >> shift) & mask );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
// verify_method performs an extra check on a matched intrinsic method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   983
static bool match_method(Method* m, Symbol* n, Symbol* s) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
  return (m->name() == n &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
          m->signature() == s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   988
static vmIntrinsics::ID match_method_with_klass(Method* m, Symbol* mk) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
#define VM_INTRINSIC_MATCH(id, klassname, namepart, sigpart, flags) \
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   990
  { Symbol* k = vmSymbols::klassname(); \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    if (mk == k) { \
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   992
      Symbol* n = vmSymbols::namepart(); \
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   993
      Symbol* s = vmSymbols::sigpart(); \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
      if (match_method(m, n, s)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
        return vmIntrinsics::id; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
    } }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  VM_INTRINSICS_DO(VM_INTRINSIC_MATCH,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
                   VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  return vmIntrinsics::_none;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
#undef VM_INTRINSIC_MATCH
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1003
void vmIntrinsics::verify_method(ID actual_id, Method* m) {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13968
diff changeset
  1004
  Symbol* mk = m->method_holder()->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  ID declared_id = match_method_with_klass(m, mk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  if (declared_id == actual_id)  return; // success
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  if (declared_id == _none && actual_id != _none && mk == vmSymbols::java_lang_StrictMath()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    // Here are a few special cases in StrictMath not declared in vmSymbols.hpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    switch (actual_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
    case _min:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    case _max:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
    case _dsqrt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
      declared_id = match_method_with_klass(m, vmSymbols::java_lang_Math());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
      if (declared_id == actual_id)  return; // acceptable alias
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
      break;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46560
diff changeset
  1018
    default:
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46560
diff changeset
  1019
        break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  const char* declared_name = name_at(declared_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  const char* actual_name   = name_at(actual_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  methodHandle mh = m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  m = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  if (xtty != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
    xtty->begin_elem("intrinsic_misdeclared actual='%s' declared='%s'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
                     actual_name, declared_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    xtty->method(mh);
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 22234
diff changeset
  1032
    xtty->end_elem("%s", "");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  if (PrintMiscellaneous && (WizardMode || Verbose)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
    tty->print_cr("*** misidentified method; %s(%d) should be %s(%d):",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
                  declared_name, declared_id, actual_name, actual_id);
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1037
    mh()->print_short_name(tty);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
#endif //PRODUCT