src/hotspot/share/utilities/globalDefinitions.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 42641 hotspot/src/share/vm/utilities/globalDefinitions.cpp@0fc484157397
child 49011 a0e246b7403a
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 35529
diff changeset
     2
 * Copyright (c) 1997, 2016, 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: 670
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 670
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: 670
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: 5702
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    26
#include "runtime/os.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    27
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5702
diff changeset
    28
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    29
// Basic error support
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    31
// Info for oops within a java object.  Defaults are zero so
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    32
// things will break badly if incorrectly initialized.
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    33
int heapOopSize        = 0;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    34
int LogBytesPerHeapOop = 0;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    35
int LogBitsPerHeapOop  = 0;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    36
int BytesPerHeapOop    = 0;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    37
int BitsPerHeapOop     = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
5694
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    39
// Object alignment, in units of HeapWords.
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    40
// Defaults are -1 so things will break badly if incorrectly initialized.
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    41
int MinObjAlignment            = -1;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    42
int MinObjAlignmentInBytes     = -1;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    43
int MinObjAlignmentInBytesMask = 0;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    44
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    45
int LogMinObjAlignment         = -1;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    46
int LogMinObjAlignmentInBytes  = -1;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    47
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    48
// Oop encoding heap max
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    49
uint64_t OopEncodingHeapMax = 0;
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 670
diff changeset
    50
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
void basic_fatal(const char* msg) {
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 22234
diff changeset
    52
  fatal("%s", msg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// Something to help porters sleep at night
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
    57
void basic_types_init() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  assert(min_intx ==  (intx)CONST64(0x8000000000000000), "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  assert(max_intx ==  CONST64(0x7FFFFFFFFFFFFFFF), "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  assert(max_uintx == CONST64(0xFFFFFFFFFFFFFFFF), "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  assert( 8 == sizeof( intx),      "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  assert( 8 == sizeof( jobject),   "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  assert(min_intx ==  (intx)0x80000000,  "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  assert(max_intx ==  0x7FFFFFFF,  "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  assert(max_uintx == 0xFFFFFFFF,  "correct constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  assert( 4 == sizeof( intx),      "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  assert( 4 == sizeof( jobject),   "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  assert( (~max_juint) == 0,  "max_juint has all its bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  assert( (~max_uintx) == 0,  "max_uintx has all its bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  assert( (~max_julong) == 0, "max_julong has all its bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  assert( 1 == sizeof( jbyte),     "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  assert( 2 == sizeof( jchar),     "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  assert( 2 == sizeof( jshort),    "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  assert( 4 == sizeof( juint),     "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  assert( 4 == sizeof( jint),      "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  assert( 1 == sizeof( jboolean),  "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  assert( 8 == sizeof( jlong),     "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  assert( 4 == sizeof( jfloat),    "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  assert( 8 == sizeof( jdouble),   "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  assert( 1 == sizeof( u1),        "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  assert( 2 == sizeof( u2),        "wrong size for basic type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  assert( 4 == sizeof( u4),        "wrong size for basic type");
35898
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 35529
diff changeset
    87
  assert(wordSize == BytesPerWord, "should be the same since they're used interchangeably");
ddc274f0052f 8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents: 35529
diff changeset
    88
  assert(wordSize == HeapWordSize, "should be the same since they're also used interchangeably");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  int num_type_chars = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  for (int i = 0; i < 99; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    if (type2char((BasicType)i) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
      assert(char2type(type2char((BasicType)i)) == i, "proper inverses");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
      num_type_chars++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  assert(num_type_chars == 11, "must have tested the right number of mappings");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  assert(char2type(0) == T_ILLEGAL, "correct illegality");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
      BasicType vt = (BasicType)i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
      BasicType ft = type2field[vt];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
      switch (vt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
      // the following types might plausibly show up in memory layouts:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
      case T_BOOLEAN:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
      case T_BYTE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
      case T_CHAR:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
      case T_SHORT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
      case T_INT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
      case T_FLOAT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
      case T_DOUBLE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
      case T_LONG:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
      case T_OBJECT:
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   115
      case T_ADDRESS:     // random raw pointer
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   116
      case T_METADATA:    // metadata pointer
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   117
      case T_NARROWOOP:   // compressed pointer
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   118
      case T_NARROWKLASS: // compressed klass pointer
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   119
      case T_CONFLICT:    // might as well support a bottom type
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   120
      case T_VOID:        // padding or other unaddressed word
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
        // layout type must map to itself
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
        assert(vt == ft, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
        // non-layout type must map to a (different) layout type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
        assert(vt != ft, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
        assert(ft == type2field[ft], "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
      // every type must map to same-sized layout type:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
      assert(type2size[vt] == type2size[ft], "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // These are assumed, e.g., when filling HeapWords with juints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  assert(is_power_of_2(sizeof(juint)), "juint must be power of 2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  assert(is_power_of_2(HeapWordSize), "HeapWordSize must be power of 2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  assert((size_t)HeapWordSize >= sizeof(juint),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
         "HeapWord should be at least as large as juint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  assert(sizeof(NULL) == sizeof(char*), "NULL must be same size as pointer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  if( JavaPriority1_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    os::java_to_os_priority[1] = JavaPriority1_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  if( JavaPriority2_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    os::java_to_os_priority[2] = JavaPriority2_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  if( JavaPriority3_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    os::java_to_os_priority[3] = JavaPriority3_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  if( JavaPriority4_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    os::java_to_os_priority[4] = JavaPriority4_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  if( JavaPriority5_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    os::java_to_os_priority[5] = JavaPriority5_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  if( JavaPriority6_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    os::java_to_os_priority[6] = JavaPriority6_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  if( JavaPriority7_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    os::java_to_os_priority[7] = JavaPriority7_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  if( JavaPriority8_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    os::java_to_os_priority[8] = JavaPriority8_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  if( JavaPriority9_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    os::java_to_os_priority[9] = JavaPriority9_To_OSPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  if(JavaPriority10_To_OSPriority != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    os::java_to_os_priority[10] = JavaPriority10_To_OSPriority;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   161
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   162
  // Set the size of basic types here (after argument parsing but before
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   163
  // stub generation).
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   164
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   165
    // Size info for oops within java objects is fixed
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   166
    heapOopSize        = jintSize;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   167
    LogBytesPerHeapOop = LogBytesPerInt;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   168
    LogBitsPerHeapOop  = LogBitsPerInt;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   169
    BytesPerHeapOop    = BytesPerInt;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   170
    BitsPerHeapOop     = BitsPerInt;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   171
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   172
    heapOopSize        = oopSize;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   173
    LogBytesPerHeapOop = LogBytesPerWord;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   174
    LogBitsPerHeapOop  = LogBitsPerWord;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   175
    BytesPerHeapOop    = BytesPerWord;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   176
    BitsPerHeapOop     = BitsPerWord;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   177
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   178
  _type2aelembytes[T_OBJECT] = heapOopSize;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   179
  _type2aelembytes[T_ARRAY]  = heapOopSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
// Map BasicType to signature character
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   184
char type2char_tab[T_CONFLICT+1]={ 0, 0, 0, 0, 'Z', 'C', 'F', 'D', 'B', 'S', 'I', 'J', 'L', '[', 'V', 0, 0, 0, 0, 0};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
// Map BasicType to Java type name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
const char* type2name_tab[T_CONFLICT+1] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  NULL, NULL, NULL, NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  "boolean",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  "char",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  "float",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  "double",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  "byte",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  "short",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  "int",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  "long",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  "object",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  "array",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  "void",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  "*address*",
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   201
  "*narrowoop*",
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 7397
diff changeset
   202
  "*metadata*",
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   203
  "*narrowklass*",
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  "*conflict*"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
BasicType name2type(const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  for (int i = T_BOOLEAN; i <= T_VOID; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    BasicType t = (BasicType)i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    if (type2name_tab[t] != NULL && 0 == strcmp(type2name_tab[t], name))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
      return t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  return T_ILLEGAL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
// Map BasicType to size in words
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   218
int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, -1};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
BasicType type2field[T_CONFLICT+1] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  (BasicType)0,            // 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  (BasicType)0,            // 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  (BasicType)0,            // 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  (BasicType)0,            // 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  T_BOOLEAN,               // T_BOOLEAN  =  4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  T_CHAR,                  // T_CHAR     =  5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  T_FLOAT,                 // T_FLOAT    =  6,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  T_DOUBLE,                // T_DOUBLE   =  7,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  T_BYTE,                  // T_BYTE     =  8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  T_SHORT,                 // T_SHORT    =  9,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  T_INT,                   // T_INT      = 10,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  T_LONG,                  // T_LONG     = 11,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  T_OBJECT,                // T_OBJECT   = 12,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  T_OBJECT,                // T_ARRAY    = 13,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  T_VOID,                  // T_VOID     = 14,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  T_ADDRESS,               // T_ADDRESS  = 15,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   237
  T_NARROWOOP,             // T_NARROWOOP= 16,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 7397
diff changeset
   238
  T_METADATA,              // T_METADATA = 17,
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   239
  T_NARROWKLASS,           // T_NARROWKLASS = 18,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   240
  T_CONFLICT               // T_CONFLICT = 19,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
BasicType type2wfield[T_CONFLICT+1] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  (BasicType)0,            // 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  (BasicType)0,            // 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  (BasicType)0,            // 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  (BasicType)0,            // 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  T_INT,     // T_BOOLEAN  =  4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  T_INT,     // T_CHAR     =  5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  T_FLOAT,   // T_FLOAT    =  6,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  T_DOUBLE,  // T_DOUBLE   =  7,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  T_INT,     // T_BYTE     =  8,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  T_INT,     // T_SHORT    =  9,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  T_INT,     // T_INT      = 10,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  T_LONG,    // T_LONG     = 11,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  T_OBJECT,  // T_OBJECT   = 12,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  T_OBJECT,  // T_ARRAY    = 13,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  T_VOID,    // T_VOID     = 14,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  T_ADDRESS, // T_ADDRESS  = 15,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   261
  T_NARROWOOP, // T_NARROWOOP  = 16,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 7397
diff changeset
   262
  T_METADATA,  // T_METADATA   = 17,
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   263
  T_NARROWKLASS, // T_NARROWKLASS  = 18,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   264
  T_CONFLICT // T_CONFLICT = 19,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
202
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   268
int _type2aelembytes[T_CONFLICT+1] = {
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   269
  0,                         // 0
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   270
  0,                         // 1
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   271
  0,                         // 2
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   272
  0,                         // 3
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   273
  T_BOOLEAN_aelem_bytes,     // T_BOOLEAN  =  4,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   274
  T_CHAR_aelem_bytes,        // T_CHAR     =  5,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   275
  T_FLOAT_aelem_bytes,       // T_FLOAT    =  6,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   276
  T_DOUBLE_aelem_bytes,      // T_DOUBLE   =  7,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   277
  T_BYTE_aelem_bytes,        // T_BYTE     =  8,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   278
  T_SHORT_aelem_bytes,       // T_SHORT    =  9,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   279
  T_INT_aelem_bytes,         // T_INT      = 10,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   280
  T_LONG_aelem_bytes,        // T_LONG     = 11,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   281
  T_OBJECT_aelem_bytes,      // T_OBJECT   = 12,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   282
  T_ARRAY_aelem_bytes,       // T_ARRAY    = 13,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   283
  0,                         // T_VOID     = 14,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   284
  T_OBJECT_aelem_bytes,      // T_ADDRESS  = 15,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   285
  T_NARROWOOP_aelem_bytes,   // T_NARROWOOP= 16,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   286
  T_OBJECT_aelem_bytes,      // T_METADATA = 17,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   287
  T_NARROWKLASS_aelem_bytes, // T_NARROWKLASS= 18,
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13742
diff changeset
   288
  0                          // T_CONFLICT = 19,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
202
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   291
#ifdef ASSERT
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   292
int type2aelembytes(BasicType t, bool allow_address) {
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   293
  assert(allow_address || t != T_ADDRESS, " ");
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   294
  return _type2aelembytes[t];
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   295
}
dc13bf0e5d5d 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 1
diff changeset
   296
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
// Support for 64-bit integer arithmetic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
// The following code is mostly taken from JVM typedefs_md.h and system_md.c
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 202
diff changeset
   302
static const jlong high_bit   = (jlong)1 << (jlong)63;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
static const jlong other_bits = ~high_bit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
jlong float2long(jfloat f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  jlong tmp = (jlong) f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  if (tmp != high_bit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    return tmp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
    if (g_isnan((jdouble)f)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    if (f < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
      return high_bit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
      return other_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
jlong double2long(jdouble f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  jlong tmp = (jlong) f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  if (tmp != high_bit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    return tmp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    if (g_isnan(f)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    if (f < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
      return high_bit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
      return other_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
// least common multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
size_t lcm(size_t a, size_t b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    size_t cur, div, next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    cur = MAX2(a, b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    div = MIN2(a, b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    assert(div != 0, "lcm requires positive arguments");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    while ((next = cur % div) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
        cur = div; div = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    julong result = julong(a) * b / div;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    assert(result <= (size_t)max_uintx, "Integer overflow in lcm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    return size_t(result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
}
16670
4af09aff4237 8003310: Enable -Wunused-function when compiling with gcc
mikael
parents: 13969
diff changeset
   358
37056
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   359
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   360
// Test that nth_bit macro and friends behave as
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   361
// expected, even with low-precedence operators.
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   362
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   363
STATIC_ASSERT(nth_bit(3)   == 0x8);
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   364
STATIC_ASSERT(nth_bit(1|2) == 0x8);
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   365
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   366
STATIC_ASSERT(right_n_bits(3)   == 0x7);
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   367
STATIC_ASSERT(right_n_bits(1|2) == 0x7);
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   368
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   369
STATIC_ASSERT(left_n_bits(3)   == (intptr_t) LP64_ONLY(0xE000000000000000) NOT_LP64(0xE0000000));
109f610020fa 8150617: nth_bit and friends are broken
stefank
parents: 35898
diff changeset
   370
STATIC_ASSERT(left_n_bits(1|2) == (intptr_t) LP64_ONLY(0xE000000000000000) NOT_LP64(0xE0000000));