/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

// 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

};

// 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 required 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;

}

const size_t K                  = 1024;

const size_t M                  = K*K;

const size_t G                  = M*K;

const size_t HWperKB            = K / sizeof(HeapWord);

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

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

// 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

inline const char* proper_unit_for_byte_size(size_t s) {

  if (s >= 10*M) {

    return "M";

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

    return "K";

  } else {

    return "B";

  }

}

inline size_t byte_size_in_proper_unit(size_t s) {

  if (s >= 10*M) {

    return s/M;

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

    return s/K;

  } else {

    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 void* left,

                            const 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));

}

//

// 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 somecase 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) ((func_type)(castable_address(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

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

// JVM spec restrictions

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

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

// 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.

const int MinObjAlignment            = HeapWordsPerLong;

const int MinObjAlignmentInBytes     = MinObjAlignment * HeapWordSize;

const int MinObjAlignmentInBytesMask = MinObjAlignmentInBytes - 1;

const int LogMinObjAlignment         = LogHeapWordsPerLong;

const int LogMinObjAlignmentInBytes  = LogMinObjAlignment + LogHeapWordSize;

// Machine dependent stuff

#include "incls/_globalDefinitions_pd.hpp.incl"

// 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 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);

}

// Align objects by rounding up their size, in HeapWord units.

#define align_object_size_(size) align_size_up_(size, MinObjAlignment)

inline intptr_t align_object_size(intptr_t size) {

  return align_size_up(size, MinObjAlignment);

}

// Pad out certain offsets to jlong alignment, in HeapWord units.

#define align_object_offset_(offset) align_size_up_(offset, HeapWordsPerLong)

inline intptr_t align_object_offset(intptr_t offset) {

  return align_size_up(offset, HeapWordsPerLong);

}

inline bool is_object_aligned(intptr_t offset) {

  return offset == align_object_offset(offset);

}

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

// Utility macros for compilers

// used to silence compiler warnings

#define Unused_Variable(var) var

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

// Miscellaneous

// 6302670 Eliminate Hotspot __fabsf dependency

// All fabs() callers should call this function instead, which will implicitly

// convert the operand to double, avoiding a dependency on __fabsf which

// doesn't exist in early versions of Solaris 8.

inline double fabsd(double value) {

  return fabs(value);

}

inline jint low (jlong value)                    { return jint(value); }

inline jint high(jlong value)                    { return jint(value >> 32); }

// the fancy casts are a hopefully portable way

// to do unsigned 32 to 64 bit type conversion

inline void set_low (jlong* value, jint low )    { *value &= (jlong)0xffffffff << 32;

                                                   *value |= (jlong)(julong)(juint)low; }

inline void set_high(jlong* value, jint high)    { *value &= (jlong)(julong)(juint)0xffffffff;

                                                   *value |= (jlong)high       << 32; }

inline jlong jlong_from(jint h, jint l) {

  jlong result = 0; // initialization to avoid warning

  set_high(&result, h);

  set_low(&result,  l);

  return result;

}

union jlong_accessor {

  jint  words[2];

  jlong long_value;

};

void basic_types_init(); // cannot define here; uses assert

// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java

enum BasicType {

  T_BOOLEAN  =  4,

  T_CHAR     =  5,

  T_FLOAT    =  6,

  T_DOUBLE   =  7,

  T_BYTE     =  8,

  T_SHORT    =  9,

  T_INT      = 10,

  T_LONG     = 11,

  T_OBJECT   = 12,

  T_ARRAY    = 13,

  T_VOID     = 14,

  T_ADDRESS  = 15,

  T_NARROWOOP= 16,

  T_CONFLICT = 17, // for stack value type with conflicting contents

  T_ILLEGAL  = 99

};

inline bool is_java_primitive(BasicType t) {

  return T_BOOLEAN <= t && t <= T_LONG;

}

// Convert a char from a classfile signature to a BasicType

inline BasicType char2type(char c) {

  switch( c ) {

  case 'B': return T_BYTE;

  case 'C': return T_CHAR;

  case 'D': return T_DOUBLE;

  case 'F': return T_FLOAT;

  case 'I': return T_INT;

  case 'J': return T_LONG;

  case 'S': return T_SHORT;

  case 'Z': return T_BOOLEAN;

  case 'V': return T_VOID;

  case 'L': return T_OBJECT;

  case '[': return T_ARRAY;

  }

  return T_ILLEGAL;

}

extern char type2char_tab[T_CONFLICT+1];     // Map a BasicType to a jchar

inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; }

extern int type2size[T_CONFLICT+1];         // Map BasicType to result stack elements

extern const char* type2name_tab[T_CONFLICT+1];     // Map a BasicType to a jchar

inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL; }

extern BasicType name2type(const char* name);

// Auxilary math routines

// least common multiple

extern size_t lcm(size_t a, size_t b);

// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java

enum BasicTypeSize {

  T_BOOLEAN_size = 1,

  T_CHAR_size    = 1,

  T_FLOAT_size   = 1,

  T_DOUBLE_size  = 2,

  T_BYTE_size    = 1,

  T_SHORT_size   = 1,

  T_INT_size     = 1,

  T_LONG_size    = 2,

  T_OBJECT_size  = 1,

  T_ARRAY_size   = 1,

  T_NARROWOOP_size = 1,

  T_VOID_size    = 0

};

// maps a BasicType to its instance field storage type:

// all sub-word integral types are widened to T_INT

extern BasicType type2field[T_CONFLICT+1];

extern BasicType type2wfield[T_CONFLICT+1];

// size in bytes

enum ArrayElementSize {

  T_BOOLEAN_aelem_bytes = 1,

  T_CHAR_aelem_bytes    = 2,

  T_FLOAT_aelem_bytes   = 4,

  T_DOUBLE_aelem_bytes  = 8,

  T_BYTE_aelem_bytes    = 1,

  T_SHORT_aelem_bytes   = 2,

  T_INT_aelem_bytes     = 4,

  T_LONG_aelem_bytes    = 8,

#ifdef _LP64

  T_OBJECT_aelem_bytes  = 8,

  T_ARRAY_aelem_bytes   = 8,

#else

  T_OBJECT_aelem_bytes  = 4,

  T_ARRAY_aelem_bytes   = 4,

#endif

  T_NARROWOOP_aelem_bytes = 4,

  T_VOID_aelem_bytes    = 0

};

extern int _type2aelembytes[T_CONFLICT+1]; // maps a BasicType to nof bytes used by its array element

#ifdef ASSERT

extern int type2aelembytes(BasicType t, bool allow_address = false); // asserts

#else

inline int type2aelembytes(BasicType t) { return _type2aelembytes[t]; }

#endif

// JavaValue serves as a container for arbitrary Java values.

class JavaValue {

 public:

  typedef union JavaCallValue {

    jfloat   f;

    jdouble  d;

    jint     i;

    jlong    l;

    jobject  h;

  } JavaCallValue;

 private:

  BasicType _type;

  JavaCallValue _value;

 public:

  JavaValue(BasicType t = T_ILLEGAL) { _type = t; }

  JavaValue(jfloat value) {

    _type    = T_FLOAT;

    _value.f = value;

  }

  JavaValue(jdouble value) {

    _type    = T_DOUBLE;

    _value.d = value;

  }

 jfloat get_jfloat() const { return _value.f; }