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