/*

 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP

#define SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP

#ifdef TARGET_COMPILER_gcc

# include "utilities/globalDefinitions_gcc.hpp"

#endif

#ifdef TARGET_COMPILER_visCPP

# include "utilities/globalDefinitions_visCPP.hpp"

#endif

#ifdef TARGET_COMPILER_sparcWorks

# include "utilities/globalDefinitions_sparcWorks.hpp"

#endif

#ifdef TARGET_COMPILER_xlc

# include "utilities/globalDefinitions_xlc.hpp"

#endif

#ifndef NOINLINE

#define NOINLINE

#endif

#ifndef ALWAYSINLINE

#define ALWAYSINLINE inline

#endif

#ifndef PRAGMA_DIAG_PUSH

#define PRAGMA_DIAG_PUSH

#endif

#ifndef PRAGMA_DIAG_POP

#define PRAGMA_DIAG_POP

#endif

#ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED

#define PRAGMA_FORMAT_NONLITERAL_IGNORED

#endif

#ifndef PRAGMA_FORMAT_IGNORED

#define PRAGMA_FORMAT_IGNORED

#endif

#ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL

#define PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL

#endif

#ifndef PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL

#define PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL

#endif

#ifndef ATTRIBUTE_PRINTF

#define ATTRIBUTE_PRINTF(fmt, vargs)

#endif

#ifndef ATTRIBUTE_SCANF

#define ATTRIBUTE_SCANF(fmt, vargs)

#endif

#include "utilities/macros.hpp"

// This file holds all globally used constants & types, class (forward)

// declarations and a few frequently used utility functions.

//----------------------------------------------------------------------------------------------------

// Constants

const int LogBytesPerShort   = 1;

const int LogBytesPerInt     = 2;

#ifdef _LP64

const int LogBytesPerWord    = 3;

#else

const int LogBytesPerWord    = 2;

#endif

const int LogBytesPerLong    = 3;

const int BytesPerShort      = 1 << LogBytesPerShort;

const int BytesPerInt        = 1 << LogBytesPerInt;

const int BytesPerWord       = 1 << LogBytesPerWord;

const int BytesPerLong       = 1 << LogBytesPerLong;

const int LogBitsPerByte     = 3;

const int LogBitsPerShort    = LogBitsPerByte + LogBytesPerShort;

const int LogBitsPerInt      = LogBitsPerByte + LogBytesPerInt;

const int LogBitsPerWord     = LogBitsPerByte + LogBytesPerWord;

const int LogBitsPerLong     = LogBitsPerByte + LogBytesPerLong;

const int BitsPerByte        = 1 << LogBitsPerByte;

const int BitsPerShort       = 1 << LogBitsPerShort;

const int BitsPerInt         = 1 << LogBitsPerInt;

const int BitsPerWord        = 1 << LogBitsPerWord;

const int BitsPerLong        = 1 << LogBitsPerLong;

const int WordAlignmentMask  = (1 << LogBytesPerWord) - 1;

const int LongAlignmentMask  = (1 << LogBytesPerLong) - 1;

const int WordsPerLong       = 2;       // Number of stack entries for longs

const int oopSize            = sizeof(char*); // Full-width oop

extern int heapOopSize;                       // Oop within a java object

const int wordSize           = sizeof(char*);

const int longSize           = sizeof(jlong);

const int jintSize           = sizeof(jint);

const int size_tSize         = sizeof(size_t);

const int BytesPerOop        = BytesPerWord;  // Full-width oop

extern int LogBytesPerHeapOop;                // Oop within a java object

extern int LogBitsPerHeapOop;

extern int BytesPerHeapOop;

extern int BitsPerHeapOop;

const int BitsPerJavaInteger = 32;

const int BitsPerJavaLong    = 64;

const int BitsPerSize_t      = size_tSize * BitsPerByte;

// Size of a char[] needed to represent a jint as a string in decimal.

const int jintAsStringSize = 12;

// In fact this should be

// log2_intptr(sizeof(class JavaThread)) - log2_intptr(64);

// see os::set_memory_serialize_page()

#ifdef _LP64

const int SerializePageShiftCount = 4;

#else

const int SerializePageShiftCount = 3;

#endif

// An opaque struct of heap-word width, so that HeapWord* can be a generic

// pointer into the heap.  We require that object sizes be measured in

// units of heap words, so that that

//   HeapWord* hw;

//   hw += oop(hw)->foo();

// works, where foo is a method (like size or scavenge) that returns the

// object size.

class HeapWord {

  friend class VMStructs;

 private:

  char* i;

#ifndef PRODUCT

 public:

  char* value() { return i; }

#endif

};

// Analogous opaque struct for metadata allocated from

// metaspaces.

class MetaWord {

 private:

  char* i;

};

// HeapWordSize must be 2^LogHeapWordSize.

const int HeapWordSize        = sizeof(HeapWord);

#ifdef _LP64

const int LogHeapWordSize     = 3;

#else

const int LogHeapWordSize     = 2;

#endif

const int HeapWordsPerLong    = BytesPerLong / HeapWordSize;

const int LogHeapWordsPerLong = LogBytesPerLong - LogHeapWordSize;

// The larger HeapWordSize for 64bit requires larger heaps

// for the same application running in 64bit.  See bug 4967770.

// The minimum alignment to a heap word size is done.  Other

// parts of the memory system may require additional alignment

// and are responsible for those alignments.

#ifdef _LP64

#define ScaleForWordSize(x) align_size_down_((x) * 13 / 10, HeapWordSize)

#else

#define ScaleForWordSize(x) (x)

#endif

// The minimum number of native machine words necessary to contain "byte_size"

// bytes.

inline size_t heap_word_size(size_t byte_size) {

  return (byte_size + (HeapWordSize-1)) >> LogHeapWordSize;

}

//-------------------------------------------

// Constant for jlong (standardized by C++11)

// Build a 64bit integer constant

#define CONST64(x)  (x ## LL)

#define UCONST64(x) (x ## ULL)

const jlong min_jlong = CONST64(0x8000000000000000);

const jlong max_jlong = CONST64(0x7fffffffffffffff);

const size_t K                  = 1024;

const size_t M                  = K*K;

const size_t G                  = M*K;

const size_t HWperKB            = K / sizeof(HeapWord);

// Constants for converting from a base unit to milli-base units.  For

// example from seconds to milliseconds and microseconds

const int MILLIUNITS    = 1000;         // milli units per base unit

const int MICROUNITS    = 1000000;      // micro units per base unit

const int NANOUNITS     = 1000000000;   // nano units per base unit

const jlong NANOSECS_PER_SEC      = CONST64(1000000000);

const jint  NANOSECS_PER_MILLISEC = 1000000;

inline const char* proper_unit_for_byte_size(size_t s) {

#ifdef _LP64

  if (s >= 10*G) {

    return "G";

  }

#endif

  if (s >= 10*M) {

    return "M";

  } else if (s >= 10*K) {

    return "K";

  } else {

    return "B";

  }

}

template <class T>

inline T byte_size_in_proper_unit(T s) {

#ifdef _LP64

  if (s >= 10*G) {

    return (T)(s/G);

  }

#endif

  if (s >= 10*M) {

    return (T)(s/M);

  } else if (s >= 10*K) {

    return (T)(s/K);

  } else {

    return s;

  }

}

inline const char* exact_unit_for_byte_size(size_t s) {

#ifdef _LP64

  if (s >= G && (s % G) == 0) {

    return "G";

  }

#endif

  if (s >= M && (s % M) == 0) {

    return "M";

  }

  if (s >= K && (s % K) == 0) {

    return "K";

  }

  return "B";

}

inline size_t byte_size_in_exact_unit(size_t s) {

#ifdef _LP64

  if (s >= G && (s % G) == 0) {

    return s / G;

  }

#endif

  if (s >= M && (s % M) == 0) {

    return s / M;

  }

  if (s >= K && (s % K) == 0) {

    return s / K;

  }

  return s;

}

//----------------------------------------------------------------------------------------------------

// VM type definitions

// intx and uintx are the 'extended' int and 'extended' unsigned int types;

// they are 32bit wide on a 32-bit platform, and 64bit wide on a 64bit platform.

typedef intptr_t  intx;

typedef uintptr_t uintx;

const intx  min_intx  = (intx)1 << (sizeof(intx)*BitsPerByte-1);

const intx  max_intx  = (uintx)min_intx - 1;

const uintx max_uintx = (uintx)-1;

// Table of values:

//      sizeof intx         4               8

// min_intx             0x80000000      0x8000000000000000

// max_intx             0x7FFFFFFF      0x7FFFFFFFFFFFFFFF

// max_uintx            0xFFFFFFFF      0xFFFFFFFFFFFFFFFF

typedef unsigned int uint;   NEEDS_CLEANUP

//----------------------------------------------------------------------------------------------------

// Java type definitions

// All kinds of 'plain' byte addresses

typedef   signed char s_char;

typedef unsigned char u_char;

typedef u_char*       address;

typedef uintptr_t     address_word; // unsigned integer which will hold a pointer

                                    // except for some implementations of a C++

                                    // linkage pointer to function. Should never

                                    // need one of those to be placed in this

                                    // type anyway.

//  Utility functions to "portably" (?) bit twiddle pointers

//  Where portable means keep ANSI C++ compilers quiet

inline address       set_address_bits(address x, int m)       { return address(intptr_t(x) | m); }

inline address       clear_address_bits(address x, int m)     { return address(intptr_t(x) & ~m); }

//  Utility functions to "portably" make cast to/from function pointers.

inline address_word  mask_address_bits(address x, int m)      { return address_word(x) & m; }

inline address_word  castable_address(address x)              { return address_word(x) ; }

inline address_word  castable_address(void* x)                { return address_word(x) ; }

// Pointer subtraction.

// The idea here is to avoid ptrdiff_t, which is signed and so doesn't have

// the range we might need to find differences from one end of the heap

// to the other.

// A typical use might be:

//     if (pointer_delta(end(), top()) >= size) {

//       // enough room for an object of size

//       ...

// and then additions like

//       ... top() + size ...

// are safe because we know that top() is at least size below end().

inline size_t pointer_delta(const volatile void* left,

                            const volatile void* right,

                            size_t element_size) {

  return (((uintptr_t) left) - ((uintptr_t) right)) / element_size;

}

// A version specialized for HeapWord*'s.

inline size_t pointer_delta(const HeapWord* left, const HeapWord* right) {

  return pointer_delta(left, right, sizeof(HeapWord));

}

// A version specialized for MetaWord*'s.

inline size_t pointer_delta(const MetaWord* left, const MetaWord* right) {

  return pointer_delta(left, right, sizeof(MetaWord));

}

//

// ANSI C++ does not allow casting from one pointer type to a function pointer

// directly without at best a warning. This macro accomplishes it silently

// In every case that is present at this point the value be cast is a pointer

// to a C linkage function. In some case the type used for the cast reflects

// that linkage and a picky compiler would not complain. In other cases because

// there is no convenient place to place a typedef with extern C linkage (i.e

// a platform dependent header file) it doesn't. At this point no compiler seems

// picky enough to catch these instances (which are few). It is possible that

// using templates could fix these for all cases. This use of templates is likely

// so far from the middle of the road that it is likely to be problematic in

// many C++ compilers.

//

#define CAST_TO_FN_PTR(func_type, value) (reinterpret_cast<func_type>(value))

#define CAST_FROM_FN_PTR(new_type, func_ptr) ((new_type)((address_word)(func_ptr)))

// Unsigned byte types for os and stream.hpp

// Unsigned one, two, four and eigth byte quantities used for describing

// the .class file format. See JVM book chapter 4.

typedef jubyte  u1;

typedef jushort u2;

typedef juint   u4;

typedef julong  u8;

const jubyte  max_jubyte  = (jubyte)-1;  // 0xFF       largest jubyte

const jushort max_jushort = (jushort)-1; // 0xFFFF     largest jushort

const juint   max_juint   = (juint)-1;   // 0xFFFFFFFF largest juint

const julong  max_julong  = (julong)-1;  // 0xFF....FF largest julong

typedef jbyte  s1;

typedef jshort s2;

typedef jint   s4;

typedef jlong  s8;

const jbyte min_jbyte = -(1 << 7);       // smallest jbyte

const jbyte max_jbyte = (1 << 7) - 1;    // largest jbyte

const jshort min_jshort = -(1 << 15);    // smallest jshort

const jshort max_jshort = (1 << 15) - 1; // largest jshort

const jint min_jint = (jint)1 << (sizeof(jint)*BitsPerByte-1); // 0x80000000 == smallest jint

const jint max_jint = (juint)min_jint - 1;                     // 0x7FFFFFFF == largest jint

//----------------------------------------------------------------------------------------------------

// JVM spec restrictions

const int max_method_code_size = 64*K - 1;  // JVM spec, 2nd ed. section 4.8.1 (p.134)

// Default ProtectionDomainCacheSize values

const int defaultProtectionDomainCacheSize = NOT_LP64(137) LP64_ONLY(2017);

//----------------------------------------------------------------------------------------------------

// Default and minimum StringTableSize values

const int defaultStringTableSize = NOT_LP64(1009) LP64_ONLY(60013);

const int minimumStringTableSize = 1009;

const int defaultSymbolTableSize = 20011;

const int minimumSymbolTableSize = 1009;

//----------------------------------------------------------------------------------------------------

// HotSwap - for JVMTI   aka Class File Replacement and PopFrame

//

// Determines whether on-the-fly class replacement and frame popping are enabled.

#define HOTSWAP

//----------------------------------------------------------------------------------------------------

// Object alignment, in units of HeapWords.

//

// Minimum is max(BytesPerLong, BytesPerDouble, BytesPerOop) / HeapWordSize, so jlong, jdouble and

// reference fields can be naturally aligned.

extern int MinObjAlignment;

extern int MinObjAlignmentInBytes;

extern int MinObjAlignmentInBytesMask;

extern int LogMinObjAlignment;

extern int LogMinObjAlignmentInBytes;

const int LogKlassAlignmentInBytes = 3;

const int LogKlassAlignment        = LogKlassAlignmentInBytes - LogHeapWordSize;

const int KlassAlignmentInBytes    = 1 << LogKlassAlignmentInBytes;

const int KlassAlignment           = KlassAlignmentInBytes / HeapWordSize;

// Maximal size of heap where unscaled compression can be used. Also upper bound

// for heap placement: 4GB.

const  uint64_t UnscaledOopHeapMax = (uint64_t(max_juint) + 1);

// Maximal size of heap where compressed oops can be used. Also upper bound for heap

// placement for zero based compression algorithm: UnscaledOopHeapMax << LogMinObjAlignmentInBytes.

extern uint64_t OopEncodingHeapMax;

// Maximal size of compressed class space. Above this limit compression is not possible.

// Also upper bound for placement of zero based class space. (Class space is further limited

// to be < 3G, see arguments.cpp.)

const  uint64_t KlassEncodingMetaspaceMax = (uint64_t(max_juint) + 1) << LogKlassAlignmentInBytes;

// Machine dependent stuff

// The maximum size of the code cache.  Can be overridden by targets.

#define CODE_CACHE_SIZE_LIMIT (2*G)

// Allow targets to reduce the default size of the code cache.

#define CODE_CACHE_DEFAULT_LIMIT CODE_CACHE_SIZE_LIMIT

#include CPU_HEADER(globalDefinitions)

// To assure the IRIW property on processors that are not multiple copy

// atomic, sync instructions must be issued between volatile reads to

// assure their ordering, instead of after volatile stores.

// (See "A Tutorial Introduction to the ARM and POWER Relaxed Memory Models"

// by Luc Maranget, Susmit Sarkar and Peter Sewell, INRIA/Cambridge)

#ifdef CPU_NOT_MULTIPLE_COPY_ATOMIC

const bool support_IRIW_for_not_multiple_copy_atomic_cpu = true;

#else

const bool support_IRIW_for_not_multiple_copy_atomic_cpu = false;

#endif

// The byte alignment to be used by Arena::Amalloc.  See bugid 4169348.

// Note: this value must be a power of 2

#define ARENA_AMALLOC_ALIGNMENT (2*BytesPerWord)

// Signed variants of alignment helpers.  There are two versions of each, a macro

// for use in places like enum definitions that require compile-time constant

// expressions and a function for all other places so as to get type checking.

#define align_size_up_(size, alignment) (((size) + ((alignment) - 1)) & ~((alignment) - 1))

inline bool is_size_aligned(size_t size, size_t alignment) {

  return align_size_up_(size, alignment) == size;

}

inline bool is_ptr_aligned(const void* ptr, size_t alignment) {

  return align_size_up_((intptr_t)ptr, (intptr_t)alignment) == (intptr_t)ptr;

}

inline intptr_t align_size_up(intptr_t size, intptr_t alignment) {

  return align_size_up_(size, alignment);

}

#define align_size_down_(size, alignment) ((size) & ~((alignment) - 1))

inline intptr_t align_size_down(intptr_t size, intptr_t alignment) {

  return align_size_down_(size, alignment);

}

#define is_size_aligned_(size, alignment) ((size) == (align_size_up_(size, alignment)))

inline void* align_ptr_up(const void* ptr, size_t alignment) {

  return (void*)align_size_up((intptr_t)ptr, (intptr_t)alignment);

}

inline void* align_ptr_down(void* ptr, size_t alignment) {