/*

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

 *

 */

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

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, Tier2CompileThreshold,        0);

define_pd_global(intx, Tier3CompileThreshold,        0);

define_pd_global(intx, Tier4CompileThreshold,        0);

define_pd_global(intx, BackEdgeThreshold,            0);

define_pd_global(intx, Tier2BackEdgeThreshold,       0);

define_pd_global(intx, Tier3BackEdgeThreshold,       0);

define_pd_global(intx, Tier4BackEdgeThreshold,       0);

define_pd_global(intx, OnStackReplacePercentage,     0);

define_pd_global(bool, ResizeTLAB,                   false);

define_pd_global(intx, FreqInlineSize,               0);

define_pd_global(intx, InlineSmallCode,              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(uintx,PermSize,    ScaleForWordSize(4*M));

define_pd_global(uintx,MaxPermSize, ScaleForWordSize(64*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

enum FlagValueOrigin {

  DEFAULT          = 0,

  COMMAND_LINE     = 1,

  ENVIRON_VAR      = 2,

  CONFIG_FILE      = 3,

  MANAGEMENT       = 4,

  ERGONOMIC        = 5,

  ATTACH_ON_DEMAND = 6,

  INTERNAL         = 99

};

struct Flag {

  const char *type;

  const char *name;

  void*       addr;

  const char *kind;

  FlagValueOrigin origin;

  // points to all Flags static array

  static Flag *flags;

  // number of flags

  static size_t numFlags;

  static Flag* find_flag(char* name, size_t length);

  bool is_bool() const        { return strcmp(type, "bool") == 0; }

  bool get_bool() const       { return *((bool*) addr); }

  void set_bool(bool value)   { *((bool*) addr) = value; }

  bool is_intx()  const       { return strcmp(type, "intx")  == 0; }

  intx get_intx() const       { return *((intx*) addr); }

  void set_intx(intx value)   { *((intx*) addr) = value; }

  bool is_uintx() const       { return strcmp(type, "uintx") == 0; }

  uintx get_uintx() const     { return *((uintx*) addr); }

  void set_uintx(uintx value) { *((uintx*) addr) = value; }

  bool is_uint64_t() const          { return strcmp(type, "uint64_t") == 0; }

  uint64_t get_uint64_t() const     { return *((uint64_t*) addr); }

  void set_uint64_t(uint64_t value) { *((uint64_t*) addr) = value; }

  bool is_double() const        { return strcmp(type, "double") == 0; }

  double get_double() const     { return *((double*) addr); }

  void set_double(double value) { *((double*) addr) = value; }

  bool is_ccstr() const          { return strcmp(type, "ccstr") == 0 || strcmp(type, "ccstrlist") == 0; }

  bool ccstr_accumulates() const { return strcmp(type, "ccstrlist") == 0; }

  ccstr get_ccstr() const     { return *((ccstr*) addr); }

  void set_ccstr(ccstr value) { *((ccstr*) addr) = value; }

  bool is_unlocker() const;

  bool is_unlocked() const;

  bool is_writeable() const;

  bool is_external() const;

  void print_on(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 IntFlagSetting {

  intx val;

  intx* flag;

 public:

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

  ~IntFlagSetting()                       { *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, FlagValueOrigin origin);

  static bool boolAtPut(char* name, bool* value, FlagValueOrigin 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, FlagValueOrigin origin);

  static bool intxAtPut(char* name, intx* value, FlagValueOrigin 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, FlagValueOrigin origin);

  static bool uintxAtPut(char* name, uintx* value, FlagValueOrigin 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, FlagValueOrigin origin);

  static bool uint64_tAtPut(char* name, uint64_t* value, FlagValueOrigin 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, FlagValueOrigin origin);

  static bool doubleAtPut(char* name, double* value, FlagValueOrigin 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, FlagValueOrigin origin);

  static bool ccstrAtPut(char* name, ccstr* value, FlagValueOrigin 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();

  static void printFlags() PRODUCT_RETURN;

  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

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

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

//

// 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")      \

                                                                            \

  notproduct(bool, CheckCompressedOops, true,                               \

            "generate checks in encoding/decoding code in debug VM")        \

                                                                            \

  product_pd(uintx, HeapBaseMinAddress,                                     \

            "OS specific low limit for heap base address")                  \

                                                                            \

  diagnostic(bool, PrintCompressedOopsMode, false,                          \

            "Print compressed oops base address and encoding mode")         \

                                                                            \

  /* UseMembar is theoretically a temp flag used for memory barrier         \

   * removal testing.  It was supposed to be removed before FCS but has     \

   * been re-added (see 6401008) */                                         \

  product(bool, UseMembar, false,                                           \

          "(Unstable) Issues membars on thread state transitions")          \

                                                                            \

  product(bool, PrintCommandLineFlags, false,                               \

          "Prints flags that appeared on the command line")                 \

                                                                            \

  diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug,                  \

          "Enable normal processing of flags relating to field diagnostics")\

                                                                            \

  experimental(bool, UnlockExperimentalVMOptions, false,                    \

          "Enable normal processing of flags relating to experimental features")\

                                                                            \

  product(bool, JavaMonitorsInStackTrace, true,                             \

          "Print info. about Java monitor locks when the stacks are dumped")\

                                                                            \

  product_pd(bool, UseLargePages,                                           \

          "Use large page memory")                                          \

                                                                            \

  product_pd(bool, UseLargePagesIndividualAllocation,                       \

          "Allocate large pages individually for better affinity")          \

                                                                            \

  develop(bool, LargePagesIndividualAllocationInjectError, false,           \

          "Fail large pages individual allocation")                         \

                                                                            \

  develop(bool, TracePageSizes, false,                                      \

          "Trace page size selection and usage.")                           \

                                                                            \

  product(bool, UseNUMA, false,                                             \

          "Use NUMA if available")                                          \

                                                                            \

  product(bool, ForceNUMA, false,                                           \

          "Force NUMA optimizations on single-node/UMA systems")            \

                                                                            \

  product(intx, NUMAChunkResizeWeight, 20,                                  \

          "Percentage (0-100) used to weight the current sample when "      \

          "computing exponentially decaying average for "                   \

          "AdaptiveNUMAChunkSizing")                                        \

                                                                            \

  product(intx, NUMASpaceResizeRate, 1*G,                                   \

          "Do not reallocate more that this amount per collection")         \

                                                                            \

  product(bool, UseAdaptiveNUMAChunkSizing, true,                           \

          "Enable adaptive chunk sizing for NUMA")                          \

                                                                            \

  product(bool, NUMAStats, false,                                           \

          "Print NUMA stats in detailed heap information")                  \

                                                                            \

  product(intx, NUMAPageScanRate, 256,                                      \

          "Maximum number of pages to include in the page scan procedure")  \

                                                                            \

  product_pd(bool, NeedsDeoptSuspend,                                       \

          "True for register window machines (sparc/ia64)")                 \

                                                                            \

  product(intx, UseSSE, 99,                                                 \

          "Highest supported SSE instructions set on x86/x64")              \

                                                                            \

  product(uintx, LargePageSizeInBytes, 0,                                   \

          "Large page size (0 to let VM choose the page size")              \

                                                                            \

  product(uintx, LargePageHeapSizeThreshold, 128*M,                         \

          "Use large pages if max heap is at least this big")               \

                                                                            \

  product(bool, ForceTimeHighResolution, false,                             \

          "Using high time resolution(For Win32 only)")                     \

                                                                            \

  develop(bool, TraceItables, false,                                        \

          "Trace initialization and use of itables")                        \

                                                                            \

  develop(bool, TracePcPatching, false,                                     \

          "Trace usage of frame::patch_pc")                                 \

                                                                            \

  develop(bool, TraceJumps, false,                                          \

          "Trace assembly jumps in thread ring buffer")                     \

                                                                            \

  develop(bool, TraceRelocator, false,                                      \

          "Trace the bytecode relocator")                                   \

                                                                            \

  develop(bool, TraceLongCompiles, false,                                   \

          "Print out every time compilation is longer than "                \

          "a given threashold")                                             \

                                                                            \

  develop(bool, SafepointALot, false,                                       \

          "Generates a lot of safepoints. Works with "                      \

          "GuaranteedSafepointInterval")                                    \

                                                                            \

  product_pd(bool, BackgroundCompilation,                                   \

          "A thread requesting compilation is not blocked during "          \

          "compilation")                                                    \

                                                                            \

  product(bool, PrintVMQWaitTime, false,                                    \

          "Prints out the waiting time in VM operation queue")              \

                                                                            \

  develop(bool, BailoutToInterpreterForThrows, false,                       \

          "Compiled methods which throws/catches exceptions will be "       \

          "deopt and intp.")                                                \

                                                                            \

  develop(bool, NoYieldsInMicrolock, false,                                 \

          "Disable yields in microlock")                                    \

                                                                            \

  develop(bool, TraceOopMapGeneration, false,                               \

          "Shows oopmap generation")                                        \

                                                                            \

  product(bool, MethodFlushing, true,                                       \

          "Reclamation of zombie and not-entrant methods")                  \

                                                                            \

  develop(bool, VerifyStack, false,                                         \

          "Verify stack of each thread when it is entering a runtime call") \

                                                                            \

  develop(bool, ForceUnreachable, false,                                    \

          "(amd64) Make all non code cache addresses to be unreachable with rip-rel forcing use of 64bit literal fixups") \

                                                                            \

  notproduct(bool, StressDerivedPointers, false,                            \

          "Force scavenge when a derived pointers is detected on stack "    \

          "after rtm call")                                                 \

                                                                            \

  develop(bool, TraceDerivedPointers, false,                                \

          "Trace traversal of derived pointers on stack")                   \

                                                                            \

  notproduct(bool, TraceCodeBlobStacks, false,                              \

          "Trace stack-walk of codeblobs")                                  \

                                                                            \

  product(bool, PrintJNIResolving, false,                                   \

          "Used to implement -v:jni")                                       \

                                                                            \

  notproduct(bool, PrintRewrites, false,                                    \

          "Print methods that are being rewritten")                         \

                                                                            \

  product(bool, UseInlineCaches, true,                                      \

          "Use Inline Caches for virtual calls ")                           \

                                                                            \

  develop(bool, InlineArrayCopy, true,                                      \

          "inline arraycopy native that is known to be part of "            \

          "base library DLL")                                               \

                                                                            \

  develop(bool, InlineObjectHash, true,                                     \

          "inline Object::hashCode() native that is known to be part "      \

          "of base library DLL")                                            \

                                                                            \

  develop(bool, InlineObjectCopy, true,                                     \

          "inline Object.clone and Arrays.copyOf[Range] intrinsics")        \

                                                                            \

  develop(bool, InlineNatives, true,                                        \

          "inline natives that are known to be part of base library DLL")   \

                                                                            \

  develop(bool, InlineMathNatives, true,                                    \

          "inline SinD, CosD, etc.")                                        \

                                                                            \

  develop(bool, InlineClassNatives, true,                                   \

          "inline Class.isInstance, etc")                                   \

                                                                            \

  develop(bool, InlineAtomicLong, true,                                     \

          "inline sun.misc.AtomicLong")                                     \

                                                                            \

  develop(bool, InlineThreadNatives, true,                                  \

          "inline Thread.currentThread, etc")                               \

                                                                            \

  develop(bool, InlineReflectionGetCallerClass, true,                       \

          "inline sun.reflect.Reflection.getCallerClass(), known to be part "\

          "of base library DLL")                                            \

                                                                            \

  develop(bool, InlineUnsafeOps, true,                                      \

          "inline memory ops (native methods) from sun.misc.Unsafe")        \

                                                                            \

  develop(bool, ConvertCmpD2CmpF, true,                                     \

          "Convert cmpD to cmpF when one input is constant in float range") \

                                                                            \

  develop(bool, ConvertFloat2IntClipping, true,                             \

          "Convert float2int clipping idiom to integer clipping")           \

                                                                            \

  develop(bool, SpecialStringCompareTo, true,                               \

          "special version of string compareTo")                            \

                                                                            \

  develop(bool, SpecialStringIndexOf, true,                                 \

          "special version of string indexOf")                              \

                                                                            \

  develop(bool, SpecialStringEquals, true,                                  \

          "special version of string equals")                               \

                                                                            \

  develop(bool, SpecialArraysEquals, true,                                  \

          "special version of Arrays.equals(char[],char[])")                \

                                                                            \

  product(bool, UseSSE42Intrinsics, false,                                  \

          "SSE4.2 versions of intrinsics")                                  \

                                                                            \

  develop(bool, TraceCallFixup, false,                                      \

          "traces all call fixups")                                         \

                                                                            \

  develop(bool, DeoptimizeALot, false,                                      \

          "deoptimize at every exit from the runtime system")               \

                                                                            \

  notproduct(ccstrlist, DeoptimizeOnlyAt, "",                               \

          "a comma separated list of bcis to deoptimize at")                \

                                                                            \

  product(bool, DeoptimizeRandom, false,                                    \

          "deoptimize random frames on random exit from the runtime system")\

                                                                            \