Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Java/Openjdk/src/hotspot/share/runtime/flags/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 6 kB

SSL jvmFlagLimit.hpp Sprache: C

/*
* Copyright (c) 2020, 2021, 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_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP
#define SHARE_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP

#include "runtime/flags/jvmFlag.hpp"

class outputStream;
template <typename T> class JVMTypedFlagLimit;

enum class JVMFlagConstraintPhase : int {
  // Will be validated during argument processing (Arguments::parse_argument).
  AtParse         = 0,
  // Will be validated inside Threads::create_vm(), right after Arguments::apply_ergo().
  AfterErgo       = 1,
  // Will be validated inside universe_init(), right after Metaspace::global_initialize().
  AfterMemoryInit = 2
};

typedef JVMFlag::Error (*JVMFlagConstraintFunc_bool)(bool value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_int)(int value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_intx)(intx value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_uint)(uint value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_uintx)(uintx value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_uint64_t)(uint64_t value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_size_t)(size_t value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_double)(double value, bool verbose);
typedef JVMFlag::Error (*JVMFlagConstraintFunc_ccstr)(ccstr value, bool verbose);

template <typename T> class JVMTypedFlagLimit;

// A JVMFlagLimit is created for each JVMFlag that has a range() and/or constraint() in its declaration in
// the globals_xxx.hpp file.
//
// To query the range information of a JVMFlag:
//     JVMFlagLimit::get_range(JVMFlag*)
//     JVMFlagLimit::get_range_at(int flag_enum)
// If the given flag doesn't have a range, NULL is returned.
//
// To query the constraint information of a JVMFlag:
//     JVMFlagLimit::get_constraint(JVMFlag*)
//     JVMFlagLimit::get_constraint_at(int flag_enum)
// If the given flag doesn't have a constraint, NULL is returned.

class JVMFlagLimit {
  short _constraint_func;
  char  _phase;
  char  _kind;

#ifdef ASSERT
  int   _type_enum;
#endif

  static const JVMFlagLimit* const* flagLimits;
  static JVMFlagsEnum _last_checked;
  static JVMFlagConstraintPhase _validating_phase;

protected:
  static constexpr int HAS_RANGE = 1;
  static constexpr int HAS_CONSTRAINT = 2;

private:
  static const JVMFlagLimit* get_kind_at(JVMFlagsEnum flag_enum, int required_kind) {
    const JVMFlagLimit* limit = at(flag_enum);
    if (limit != NULL && (limit->_kind & required_kind) != 0) {
      _last_checked = flag_enum;
      return limit;
    } else {
      return NULL;
    }
  }

  static const JVMFlagLimit* at(JVMFlagsEnum flag_enum) {
    JVMFlag::assert_valid_flag_enum(flag_enum);
    return flagLimits[static_cast<int>(flag_enum)];
  }

public:
  void* constraint_func() const;
  char phase() const { return _phase; }
  char kind()  const { return _kind; }

  constexpr JVMFlagLimit(int type_enum, short func, short phase, short kind)
    : _constraint_func(func), _phase(phase), _kind(kind) DEBUG_ONLY(COMMA _type_enum(type_enum)) {}

  static const JVMFlagLimit* get_range(const JVMFlag* flag) {
    return get_range_at(flag->flag_enum());
  }
  static const JVMFlagLimit* get_range_at(JVMFlagsEnum flag_enum) {
    return get_kind_at(flag_enum, HAS_RANGE);
  }

  static const JVMFlagLimit* get_constraint(const JVMFlag* flag) {
    return get_constraint_at(flag->flag_enum());
  }
  static const JVMFlagLimit* get_constraint_at(JVMFlagsEnum flag_enum) {
    return get_kind_at(flag_enum, HAS_CONSTRAINT);
  }

  static const JVMFlag* last_checked_flag();

  // Is the current value of each JVM flag within the allowed range (if specified)
  static bool check_all_ranges();
  void print_range(outputStream* st, const JVMFlag* flag) const;

  // Does the current value of each JVM flag satisfy the specified constraint
  static bool check_all_constraints(JVMFlagConstraintPhase phase);

  // If range/constraint checks fail, print verbose error messages only if we are parsing
  // arguments from the command-line. Silently ignore any invalid values that are
  // set programmatically via FLAG_SET_ERGO, etc.
  static bool verbose_checks_needed() {
    return _validating_phase == JVMFlagConstraintPhase::AtParse;
  }

  static JVMFlagConstraintPhase validating_phase() { return _validating_phase; }

  template <typename T>
  const JVMTypedFlagLimit<T>* cast() const;
};

enum ConstraintMarker {
  next_two_args_are_constraint,
};

template <typename T>
class JVMTypedFlagLimit : public JVMFlagLimit {
  const T _min;
  const T _max;

public:
  // dummy - no range or constraint. This object will not be emitted into the .o file
  // because we declare it as "const" but has no reference to it.
  constexpr JVMTypedFlagLimit(int type_enum) :
  JVMFlagLimit(0, 0, 0, 0), _min(0), _max(0) {}

  // range only
  constexpr JVMTypedFlagLimit(int type_enum, T min, T max) :
    JVMFlagLimit(type_enum, 0, 0, HAS_RANGE), _min(min), _max(max) {}

  // constraint only
  constexpr JVMTypedFlagLimit(int type_enum, ConstraintMarker dummy2, short func, int phase) :
    JVMFlagLimit(type_enum, func, phase, HAS_CONSTRAINT), _min(0), _max(0) {}

  // range and constraint
  constexpr JVMTypedFlagLimit(int type_enum, T min, T max, ConstraintMarker dummy2, short func, int phase)  :
    JVMFlagLimit(type_enum, func, phase, HAS_RANGE | HAS_CONSTRAINT), _min(min), _max(max) {}

  // constraint and range
  constexpr JVMTypedFlagLimit(int type_enum, ConstraintMarker dummy2, short func, int phase, T min, T max)  :
    JVMFlagLimit(type_enum, func, phase, HAS_RANGE | HAS_CONSTRAINT), _min(min), _max(max) {}

  T min() const { return _min; }
  T max() const { return _max; }
};

template <typename T>
const JVMTypedFlagLimit<T>* JVMFlagLimit::cast() const {
  DEBUG_ONLY(JVMFlag::assert_compatible_type<T>(_type_enum));
  return static_cast<const JVMTypedFlagLimit<T>*>(this);
}

#endif // SHARE_RUNTIME_FLAGS_JVMFLAGLIMIT_HPP

quality100%

¤ Dauer der Verarbeitung: 0.17 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.