/*

 * Copyright (c) 1997, 2015, 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_ARCH_aarch64

# include "globals_aarch64.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_linux_aarch64

# include "globals_linux_aarch64.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_aarch64

# include "c1_globals_aarch64.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

#ifdef TARGET_ARCH_ppc

# include "c1_globals_ppc.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_ARCH_aarch64

# include "c2_globals_aarch64.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, OnStackReplacePercentage,     0);

define_pd_global(bool, ResizeTLAB,                   false);

define_pd_global(intx, FreqInlineSize,               0);

define_pd_global(size_t, 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, NonProfiledCodeHeapSize,      0);

define_pd_global(intx, ProfiledCodeHeapSize,         0);

define_pd_global(intx, NonNMethodCodeHeapSize,       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(size_t, 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

  };

  enum Error {

    // no error

    SUCCESS = 0,

    // flag name is missing

    MISSING_NAME,

    // flag value is missing

    MISSING_VALUE,

    // error parsing the textual form of the value

    WRONG_FORMAT,

    // flag is not writeable

    NON_WRITABLE,

    // flag value is outside of its bounds

    OUT_OF_BOUNDS,

    // flag value violates its constraint

    VIOLATES_CONSTRAINT,

    // there is no flag with the given name

    INVALID_FLAG,

    // other, unspecified error related to setting the flag

    ERR_OTHER

  };

  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) { return find_flag(name, strlen(name), true, true); };

  static Flag* find_flag(const char* name, size_t length, bool allow_locked = false, bool return_flag = 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_int() const;

  int get_int() const;

  void set_int(int value);

  bool is_uint() const;

  uint get_uint() const;

  void set_uint(uint 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_size_t() const;

  size_t get_size_t() const;

  void set_size_t(size_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 unlock_diagnostic();

  void get_locked_message(char*, int) const;

  void get_locked_message_ext(char*, int) const;

  // printRanges will print out flags type, name and range values as expected by -XX:+PrintFlagsRanges

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

  void print_kind(outputStream* st);

  void print_as_flag(outputStream* st);

  static const char* flag_error_str(Flag::Error error) {

    switch (error) {

      case Flag::MISSING_NAME: return "MISSING_NAME";

      case Flag::MISSING_VALUE: return "MISSING_VALUE";

      case Flag::NON_WRITABLE: return "NON_WRITABLE";

      case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS";

      case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT";

      case Flag::INVALID_FLAG: return "INVALID_FLAG";

      case Flag::ERR_OTHER: return "ERR_OTHER";

      case Flag::SUCCESS: return "SUCCESS";

      default: return "NULL";

    }

  }

};

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

  int val;

  int* flag;

 public:

  IntFlagSetting(int& fl, int newValue) { flag = &fl; val = fl; fl = newValue; }

  ~IntFlagSetting()                     { *flag = val; }

};

class UIntFlagSetting {

  uint val;

  uint* flag;

 public:

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

  ~UIntFlagSetting()                       { *flag = val; }

};

class UIntXFlagSetting {

  uintx val;

  uintx* flag;

 public:

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

  ~UIntXFlagSetting()                         { *flag = val; }

};

class DoubleFlagSetting {

  double val;

  double* flag;

 public:

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

  ~DoubleFlagSetting()                           { *flag = val; }

};

class SizeTFlagSetting {

  size_t val;

  size_t* flag;

 public:

  SizeTFlagSetting(size_t& fl, size_t newValue) { flag = &fl; val = fl; fl = newValue; }

  ~SizeTFlagSetting()                           { *flag = val; }

};

class CommandLineFlags {

  static bool _finished_initializing;

public:

  static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false)      { return boolAt(name, strlen(name), value, allow_locked, return_flag); }

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

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

  static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false)      { return intAt(name, strlen(name), value, allow_locked, return_flag); }

  static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);

  static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin)   { return intAtPut(name, strlen(name), value, origin); }

  static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false)      { return uintAt(name, strlen(name), value, allow_locked, return_flag); }

  static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);

  static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin)   { return uintAtPut(name, strlen(name), value, origin); }

  static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false)      { return intxAt(name, strlen(name), value, allow_locked, return_flag); }

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

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

  static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false)    { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }

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

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

  static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false)    { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }

  static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin);

  static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }

  static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }

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

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

  static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false)    { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }

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

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

  static Flag::Error ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked = false, bool return_flag = false);

  static Flag::Error ccstrAt(const char* name, ccstr* value, bool allow_locked = false, bool return_flag = false)    { return ccstrAt(name, strlen(name), value, allow_locked, return_flag); }