/*

 * Copyright (c) 1997, 2013, 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_RUNTIME_GLOBALS_HPP

#define SHARE_VM_RUNTIME_GLOBALS_HPP

#include "utilities/debug.hpp"

// use this for flags that are true per default in the tiered build

// but false in non-tiered builds, and vice versa

#ifdef TIERED

#define  trueInTiered true

#define falseInTiered false

#else

#define  trueInTiered false

#define falseInTiered true

#endif

#ifdef TARGET_ARCH_x86

# include "globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "globals_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "globals_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "globals_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "globals_windows.hpp"

#endif

#ifdef TARGET_OS_FAMILY_aix

# include "globals_aix.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "globals_bsd.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_x86

# include "globals_linux_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_sparc

# include "globals_linux_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_zero

# include "globals_linux_zero.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_x86

# include "globals_solaris_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_solaris_sparc

# include "globals_solaris_sparc.hpp"

#endif

#ifdef TARGET_OS_ARCH_windows_x86

# include "globals_windows_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_arm

# include "globals_linux_arm.hpp"

#endif

#ifdef TARGET_OS_ARCH_linux_ppc

# include "globals_linux_ppc.hpp"

#endif

#ifdef TARGET_OS_ARCH_aix_ppc

# include "globals_aix_ppc.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_x86

# include "globals_bsd_x86.hpp"

#endif

#ifdef TARGET_OS_ARCH_bsd_zero

# include "globals_bsd_zero.hpp"

#endif

#ifdef COMPILER1

#ifdef TARGET_ARCH_x86

# include "c1_globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "c1_globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "c1_globals_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "c1_globals_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "c1_globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "c1_globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "c1_globals_windows.hpp"

#endif

#ifdef TARGET_OS_FAMILY_aix

# include "c1_globals_aix.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "c1_globals_bsd.hpp"

#endif

#endif

#ifdef COMPILER2

#ifdef TARGET_ARCH_x86

# include "c2_globals_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "c2_globals_sparc.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "c2_globals_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "c2_globals_ppc.hpp"

#endif

#ifdef TARGET_OS_FAMILY_linux

# include "c2_globals_linux.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "c2_globals_solaris.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "c2_globals_windows.hpp"

#endif

#ifdef TARGET_OS_FAMILY_aix

# include "c2_globals_aix.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "c2_globals_bsd.hpp"

#endif

#endif

#ifdef SHARK

#ifdef TARGET_ARCH_zero

# include "shark_globals_zero.hpp"

#endif

#endif

#if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK)

define_pd_global(bool, BackgroundCompilation,        false);

define_pd_global(bool, UseTLAB,                      false);

define_pd_global(bool, CICompileOSR,                 false);

define_pd_global(bool, UseTypeProfile,               false);

define_pd_global(bool, UseOnStackReplacement,        false);

define_pd_global(bool, InlineIntrinsics,             false);

define_pd_global(bool, PreferInterpreterNativeStubs, true);

define_pd_global(bool, ProfileInterpreter,           false);

define_pd_global(bool, ProfileTraps,                 false);

define_pd_global(bool, TieredCompilation,            false);

define_pd_global(intx, CompileThreshold,             0);

define_pd_global(intx, BackEdgeThreshold,            0);

define_pd_global(intx, OnStackReplacePercentage,     0);

define_pd_global(bool, ResizeTLAB,                   false);

define_pd_global(intx, FreqInlineSize,               0);

define_pd_global(intx, NewSizeThreadIncrease,        4*K);

define_pd_global(intx, InlineClassNatives,           true);

define_pd_global(intx, InlineUnsafeOps,              true);

define_pd_global(intx, InitialCodeCacheSize,         160*K);

define_pd_global(intx, ReservedCodeCacheSize,        32*M);

define_pd_global(intx, CodeCacheExpansionSize,       32*K);

define_pd_global(intx, CodeCacheMinBlockLength,      1);

define_pd_global(intx, CodeCacheMinimumUseSpace,     200*K);

define_pd_global(uintx,MetaspaceSize,    ScaleForWordSize(4*M));

define_pd_global(bool, NeverActAsServerClassMachine, true);

define_pd_global(uint64_t,MaxRAM,                    1ULL*G);

#define CI_COMPILER_COUNT 0

#else

#ifdef COMPILER2

#define CI_COMPILER_COUNT 2

#else

#define CI_COMPILER_COUNT 1

#endif // COMPILER2

#endif // no compilers

// string type aliases used only in this file

typedef const char* ccstr;

typedef const char* ccstrlist;   // represents string arguments which accumulate

struct Flag {

  enum Flags {

    // value origin

    DEFAULT          = 0,

    COMMAND_LINE     = 1,

    ENVIRON_VAR      = 2,

    CONFIG_FILE      = 3,

    MANAGEMENT       = 4,

    ERGONOMIC        = 5,

    ATTACH_ON_DEMAND = 6,

    INTERNAL         = 7,

    LAST_VALUE_ORIGIN = INTERNAL,

    VALUE_ORIGIN_BITS = 4,

    VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS),

    // flag kind

    KIND_PRODUCT            = 1 << 4,

    KIND_MANAGEABLE         = 1 << 5,

    KIND_DIAGNOSTIC         = 1 << 6,

    KIND_EXPERIMENTAL       = 1 << 7,

    KIND_NOT_PRODUCT        = 1 << 8,

    KIND_DEVELOP            = 1 << 9,

    KIND_PLATFORM_DEPENDENT = 1 << 10,

    KIND_READ_WRITE         = 1 << 11,

    KIND_C1                 = 1 << 12,

    KIND_C2                 = 1 << 13,

    KIND_ARCH               = 1 << 14,

    KIND_SHARK              = 1 << 15,

    KIND_LP64_PRODUCT       = 1 << 16,

    KIND_COMMERCIAL         = 1 << 17,

    KIND_MASK = ~VALUE_ORIGIN_MASK

  };

  const char* _type;

  const char* _name;

  void* _addr;

  NOT_PRODUCT(const char* _doc;)

  Flags _flags;

  // points to all Flags static array

  static Flag* flags;

  // number of flags

  static size_t numFlags;

  static Flag* find_flag(const char* name, size_t length, bool allow_locked = false);

  static Flag* fuzzy_match(const char* name, size_t length, bool allow_locked = false);

  void check_writable();

  bool is_bool() const;

  bool get_bool() const;

  void set_bool(bool value);

  bool is_intx() const;

  intx get_intx() const;

  void set_intx(intx value);

  bool is_uintx() const;

  uintx get_uintx() const;

  void set_uintx(uintx value);

  bool is_uint64_t() const;

  uint64_t get_uint64_t() const;

  void set_uint64_t(uint64_t value);

  bool is_double() const;

  double get_double() const;

  void set_double(double value);

  bool is_ccstr() const;

  bool ccstr_accumulates() const;

  ccstr get_ccstr() const;

  void set_ccstr(ccstr value);

  Flags get_origin();

  void set_origin(Flags origin);

  bool is_default();

  bool is_ergonomic();

  bool is_command_line();

  bool is_product() const;

  bool is_manageable() const;

  bool is_diagnostic() const;

  bool is_experimental() const;

  bool is_notproduct() const;

  bool is_develop() const;

  bool is_read_write() const;

  bool is_commercial() const;

  bool is_constant_in_binary() const;

  bool is_unlocker() const;

  bool is_unlocked() const;

  bool is_writeable() const;

  bool is_external() const;

  bool is_unlocker_ext() const;

  bool is_unlocked_ext() const;

  bool is_writeable_ext() const;

  bool is_external_ext() const;

  void get_locked_message(char*, int) const;

  void get_locked_message_ext(char*, int) const;

  void print_on(outputStream* st, bool withComments = false );

  void print_kind(outputStream* st);

  void print_as_flag(outputStream* st);

};

// debug flags control various aspects of the VM and are global accessible

// use FlagSetting to temporarily change some debug flag

// e.g. FlagSetting fs(DebugThisAndThat, true);

// restored to previous value upon leaving scope

class FlagSetting {

  bool val;

  bool* flag;

 public:

  FlagSetting(bool& fl, bool newValue) { flag = &fl; val = fl; fl = newValue; }

  ~FlagSetting()                       { *flag = val; }

};

class CounterSetting {

  intx* counter;

 public:

  CounterSetting(intx* cnt) { counter = cnt; (*counter)++; }

  ~CounterSetting()         { (*counter)--; }

};

class UIntFlagSetting {

  uintx val;

  uintx* flag;

 public:

  UIntFlagSetting(uintx& fl, uintx newValue) { flag = &fl; val = fl; fl = newValue; }

  ~UIntFlagSetting()                         { *flag = val; }

};

class DoubleFlagSetting {

  double val;

  double* flag;

 public:

  DoubleFlagSetting(double& fl, double newValue) { flag = &fl; val = fl; fl = newValue; }

  ~DoubleFlagSetting()                           { *flag = val; }

};

class CommandLineFlags {

 public:

  static bool boolAt(char* name, size_t len, bool* value);

  static bool boolAt(char* name, bool* value)      { return boolAt(name, strlen(name), value); }

  static bool boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin);

  static bool boolAtPut(char* name, bool* value, Flag::Flags origin)   { return boolAtPut(name, strlen(name), value, origin); }

  static bool intxAt(char* name, size_t len, intx* value);

  static bool intxAt(char* name, intx* value)      { return intxAt(name, strlen(name), value); }

  static bool intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin);

  static bool intxAtPut(char* name, intx* value, Flag::Flags origin)   { return intxAtPut(name, strlen(name), value, origin); }

  static bool uintxAt(char* name, size_t len, uintx* value);

  static bool uintxAt(char* name, uintx* value)    { return uintxAt(name, strlen(name), value); }

  static bool uintxAtPut(char* name, size_t len, uintx* value, Flag::Flags origin);

  static bool uintxAtPut(char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }

  static bool uint64_tAt(char* name, size_t len, uint64_t* value);

  static bool uint64_tAt(char* name, uint64_t* value) { return uint64_tAt(name, strlen(name), value); }

  static bool uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin);

  static bool uint64_tAtPut(char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }

  static bool doubleAt(char* name, size_t len, double* value);

  static bool doubleAt(char* name, double* value)    { return doubleAt(name, strlen(name), value); }

  static bool doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin);

  static bool doubleAtPut(char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }

  static bool ccstrAt(char* name, size_t len, ccstr* value);

  static bool ccstrAt(char* name, ccstr* value)    { return ccstrAt(name, strlen(name), value); }

  static bool ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin);

  static bool ccstrAtPut(char* name, ccstr* value, Flag::Flags origin) { return ccstrAtPut(name, strlen(name), value, origin); }

  // Returns false if name is not a command line flag.

  static bool wasSetOnCmdline(const char* name, bool* value);

  static void printSetFlags(outputStream* out);

  static void printFlags(outputStream* out, bool withComments);

  static void verify() PRODUCT_RETURN;

};

// use this for flags that are true by default in the debug version but

// false in the optimized version, and vice versa

#ifdef ASSERT

#define trueInDebug  true

#define falseInDebug false

#else

#define trueInDebug  false

#define falseInDebug true

#endif

// use this for flags that are true per default in the product build

// but false in development builds, and vice versa

#ifdef PRODUCT

#define trueInProduct  true

#define falseInProduct false

#else

#define trueInProduct  false

#define falseInProduct true

#endif

#ifdef JAVASE_EMBEDDED

#define falseInEmbedded false

#else

#define falseInEmbedded true

#endif

// develop flags are settable / visible only during development and are constant in the PRODUCT version

// product flags are always settable / visible

// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version

// A flag must be declared with one of the following types:

// bool, intx, uintx, ccstr.

// The type "ccstr" is an alias for "const char*" and is used

// only in this file, because the macrology requires single-token type names.

// Note: Diagnostic options not meant for VM tuning or for product modes.

// They are to be used for VM quality assurance or field diagnosis

// of VM bugs.  They are hidden so that users will not be encouraged to

// try them as if they were VM ordinary execution options.  However, they

// are available in the product version of the VM.  Under instruction

// from support engineers, VM customers can turn them on to collect

// diagnostic information about VM problems.  To use a VM diagnostic

// option, you must first specify +UnlockDiagnosticVMOptions.

// (This master switch also affects the behavior of -Xprintflags.)

//

// experimental flags are in support of features that are not

//    part of the officially supported product, but are available

//    for experimenting with. They could, for example, be performance

//    features that may not have undergone full or rigorous QA, but which may

//    help performance in some cases and released for experimentation

//    by the community of users and developers. This flag also allows one to

//    be able to build a fully supported product that nonetheless also

//    ships with some unsupported, lightly tested, experimental features.

//    Like the UnlockDiagnosticVMOptions flag above, there is a corresponding

//    UnlockExperimentalVMOptions flag, which allows the control and

//    modification of the experimental flags.

//

// Nota bene: neither diagnostic nor experimental options should be used casually,

//    and they are not supported on production loads, except under explicit

//    direction from support engineers.

//

// manageable flags are writeable external product flags.

//    They are dynamically writeable through the JDK management interface

//    (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.

//    These flags are external exported interface (see CCC).  The list of

//    manageable flags can be queried programmatically through the management

//    interface.

//

//    A flag can be made as "manageable" only if

//    - the flag is defined in a CCC as an external exported interface.

//    - the VM implementation supports dynamic setting of the flag.

//      This implies that the VM must *always* query the flag variable

//      and not reuse state related to the flag state at any given time.

//    - you want the flag to be queried programmatically by the customers.

//

// product_rw flags are writeable internal product flags.

//    They are like "manageable" flags but for internal/private use.

//    The list of product_rw flags are internal/private flags which

//    may be changed/removed in a future release.  It can be set

//    through the management interface to get/set value

//    when the name of flag is supplied.

//

//    A flag can be made as "product_rw" only if

//    - the VM implementation supports dynamic setting of the flag.

//      This implies that the VM must *always* query the flag variable

//      and not reuse state related to the flag state at any given time.

//

// Note that when there is a need to support develop flags to be writeable,

// it can be done in the same way as product_rw.

#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \

                                                                            \

  lp64_product(bool, UseCompressedOops, false,                              \

          "Use 32-bit object references in 64-bit VM. "                     \

          "lp64_product means flag is always constant in 32 bit VM")        \

                                                                            \

  lp64_product(bool, UseCompressedClassPointers, false,                     \

          "Use 32-bit class pointers in 64-bit VM. "                        \