< prev index next >

src/hotspot/share/runtime/flags/jvmFlagRangeList.cpp

Print this page




  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "classfile/stringTable.hpp"
  28 #include "classfile/symbolTable.hpp"
  29 #include "gc/shared/referenceProcessor.hpp"
  30 #include "oops/markOop.hpp"
  31 #include "runtime/arguments.hpp"
  32 #include "runtime/flags/jvmFlag.hpp"
  33 #include "runtime/flags/jvmFlagConstraintList.hpp"
  34 #include "runtime/flags/jvmFlagRangeList.hpp"
  35 #include "runtime/globals_extension.hpp"
  36 #include "runtime/os.hpp"
  37 #include "runtime/task.hpp"
  38 #include "utilities/defaultStream.hpp"
  39 #include "utilities/macros.hpp"
  40 
  41 void CommandLineError::print(bool verbose, const char* msg, ...) {
  42   if (verbose) {
  43     va_list listPointer;
  44     va_start(listPointer, msg);
  45     jio_vfprintf(defaultStream::error_stream(), msg, listPointer);
  46     va_end(listPointer);
  47   }
  48 }
  49 
  50 class JVMFlagRange_int : public JVMFlagRange {
  51   int _min;
  52   int _max;
  53   const int* _ptr;
  54 
  55 public:
  56   // the "name" argument must be a string literal
  57   JVMFlagRange_int(const char* name, const int* ptr, int min, int max)
  58     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
  59 
  60   JVMFlag::Error check(bool verbose = true) {
  61     return check_int(*_ptr, verbose);
  62   }
  63 
  64   JVMFlag::Error check_int(int value, bool verbose = true) {
  65     if ((value < _min) || (value > _max)) {
  66       CommandLineError::print(verbose,
  67                               "int %s=%d is outside the allowed range "
  68                               "[ %d ... %d ]\n",
  69                               name(), value, _min, _max);
  70       return JVMFlag::OUT_OF_BOUNDS;
  71     } else {
  72       return JVMFlag::SUCCESS;
  73     }
  74   }
  75 
  76   void print(outputStream* st) {
  77     st->print("[ %-25d ... %25d ]", _min, _max);
  78   }
  79 };
  80 
  81 class JVMFlagRange_intx : public JVMFlagRange {
  82   intx _min;
  83   intx _max;
  84   const intx* _ptr;
  85 public:
  86   // the "name" argument must be a string literal
  87   JVMFlagRange_intx(const char* name, const intx* ptr, intx min, intx max)
  88     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
  89 
  90   JVMFlag::Error check(bool verbose = true) {
  91     return check_intx(*_ptr, verbose);
  92   }
  93 
  94   JVMFlag::Error check_intx(intx value, bool verbose = true) {
  95     if ((value < _min) || (value > _max)) {
  96       CommandLineError::print(verbose,
  97                               "intx %s=" INTX_FORMAT " is outside the allowed range "
  98                               "[ " INTX_FORMAT " ... " INTX_FORMAT " ]\n",
  99                               name(), value, _min, _max);
 100       return JVMFlag::OUT_OF_BOUNDS;
 101     } else {
 102       return JVMFlag::SUCCESS;
 103     }
 104   }
 105 
 106   void print(outputStream* st) {
 107     st->print("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", _min, _max);
 108   }
 109 };
 110 
 111 class JVMFlagRange_uint : public JVMFlagRange {
 112   uint _min;
 113   uint _max;
 114   const uint* _ptr;
 115 
 116 public:
 117   // the "name" argument must be a string literal
 118   JVMFlagRange_uint(const char* name, const uint* ptr, uint min, uint max)
 119     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 120 
 121   JVMFlag::Error check(bool verbose = true) {
 122     return check_uint(*_ptr, verbose);
 123   }
 124 
 125   JVMFlag::Error check_uint(uint value, bool verbose = true) {
 126     if ((value < _min) || (value > _max)) {
 127       CommandLineError::print(verbose,
 128                               "uint %s=%u is outside the allowed range "
 129                               "[ %u ... %u ]\n",
 130                               name(), value, _min, _max);
 131       return JVMFlag::OUT_OF_BOUNDS;
 132     } else {
 133       return JVMFlag::SUCCESS;
 134     }
 135   }
 136 
 137   void print(outputStream* st) {
 138     st->print("[ %-25u ... %25u ]", _min, _max);
 139   }
 140 };
 141 
 142 class JVMFlagRange_uintx : public JVMFlagRange {
 143   uintx _min;
 144   uintx _max;
 145   const uintx* _ptr;
 146 
 147 public:
 148   // the "name" argument must be a string literal
 149   JVMFlagRange_uintx(const char* name, const uintx* ptr, uintx min, uintx max)
 150     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 151 
 152   JVMFlag::Error check(bool verbose = true) {
 153     return check_uintx(*_ptr, verbose);
 154   }
 155 
 156   JVMFlag::Error check_uintx(uintx value, bool verbose = true) {
 157     if ((value < _min) || (value > _max)) {
 158       CommandLineError::print(verbose,
 159                               "uintx %s=" UINTX_FORMAT " is outside the allowed range "
 160                               "[ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n",
 161                               name(), value, _min, _max);
 162       return JVMFlag::OUT_OF_BOUNDS;
 163     } else {
 164       return JVMFlag::SUCCESS;
 165     }
 166   }
 167 
 168   void print(outputStream* st) {
 169     st->print("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", _min, _max);
 170   }
 171 };
 172 
 173 class JVMFlagRange_uint64_t : public JVMFlagRange {
 174   uint64_t _min;
 175   uint64_t _max;
 176   const uint64_t* _ptr;
 177 
 178 public:
 179   // the "name" argument must be a string literal
 180   JVMFlagRange_uint64_t(const char* name, const uint64_t* ptr, uint64_t min, uint64_t max)
 181     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 182 
 183   JVMFlag::Error check(bool verbose = true) {
 184     return check_uint64_t(*_ptr, verbose);
 185   }
 186 
 187   JVMFlag::Error check_uint64_t(uint64_t value, bool verbose = true) {
 188     if ((value < _min) || (value > _max)) {
 189       CommandLineError::print(verbose,
 190                               "uint64_t %s=" UINT64_FORMAT " is outside the allowed range "
 191                               "[ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n",
 192                               name(), value, _min, _max);
 193       return JVMFlag::OUT_OF_BOUNDS;
 194     } else {
 195       return JVMFlag::SUCCESS;
 196     }
 197   }
 198 
 199   void print(outputStream* st) {
 200     st->print("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", _min, _max);
 201   }
 202 };
 203 
 204 class JVMFlagRange_size_t : public JVMFlagRange {
 205   size_t _min;
 206   size_t _max;
 207   const size_t* _ptr;
 208 
 209 public:
 210   // the "name" argument must be a string literal
 211   JVMFlagRange_size_t(const char* name, const size_t* ptr, size_t min, size_t max)
 212     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 213 
 214   JVMFlag::Error check(bool verbose = true) {
 215     return check_size_t(*_ptr, verbose);
 216   }
 217 
 218   JVMFlag::Error check_size_t(size_t value, bool verbose = true) {
 219     if ((value < _min) || (value > _max)) {
 220       CommandLineError::print(verbose,
 221                               "size_t %s=" SIZE_FORMAT " is outside the allowed range "
 222                               "[ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n",
 223                               name(), value, _min, _max);
 224       return JVMFlag::OUT_OF_BOUNDS;
 225     } else {
 226       return JVMFlag::SUCCESS;
 227     }
 228   }
 229 
 230   void print(outputStream* st) {
 231     st->print("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", _min, _max);
 232   }
 233 };
 234 
 235 class JVMFlagRange_double : public JVMFlagRange {
 236   double _min;
 237   double _max;
 238   const double* _ptr;
 239 
 240 public:
 241   // the "name" argument must be a string literal
 242   JVMFlagRange_double(const char* name, const double* ptr, double min, double max)
 243     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 244 
 245   JVMFlag::Error check(bool verbose = true) {
 246     return check_double(*_ptr, verbose);
 247   }
 248 
 249   JVMFlag::Error check_double(double value, bool verbose = true) {
 250     if ((value < _min) || (value > _max)) {
 251       CommandLineError::print(verbose,
 252                               "double %s=%f is outside the allowed range "
 253                               "[ %f ... %f ]\n",
 254                               name(), value, _min, _max);
 255       return JVMFlag::OUT_OF_BOUNDS;
 256     } else {
 257       return JVMFlag::SUCCESS;
 258     }
 259   }
 260 
 261   void print(outputStream* st) {
 262     st->print("[ %-25.3f ... %25.3f ]", _min, _max);
 263   }
 264 };
 265 
 266 // No constraint emitting
 267 void emit_range_no(...)                         { /* NOP */ }
 268 
 269 // No constraint emitting if function argument is NOT provided
 270 void emit_range_bool(const char* /*name*/, const bool* /*value*/)            { /* NOP */ }
 271 void emit_range_ccstr(const char* /*name*/, const ccstr* /*value*/)          { /* NOP */ }


 415   }
 416   return found;
 417 }
 418 
 419 void JVMFlagRangeList::print(outputStream* st, const char* name, RangeStrFunc default_range_str_func) {
 420   JVMFlagRange* range = JVMFlagRangeList::find(name);
 421   if (range != NULL) {
 422     range->print(st);
 423   } else {
 424     JVMFlagConstraint* constraint = JVMFlagConstraintList::find(name);
 425     if (constraint != NULL) {
 426       assert(default_range_str_func!=NULL, "default_range_str_func must be provided");
 427       st->print("%s", default_range_str_func());
 428     } else {
 429       st->print("[                           ...                           ]");
 430     }
 431   }
 432 }
 433 
 434 bool JVMFlagRangeList::check_ranges() {
 435   // Check ranges.
 436   bool status = true;
 437   for (int i=0; i<length(); i++) {
 438     JVMFlagRange* range = at(i);
 439     if (range->check(true) != JVMFlag::SUCCESS) status = false;
 440   }
 441   return status;
 442 }


  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "classfile/stringTable.hpp"
  28 #include "classfile/symbolTable.hpp"
  29 #include "gc/shared/referenceProcessor.hpp"
  30 #include "oops/markOop.hpp"
  31 #include "runtime/arguments.hpp"
  32 #include "runtime/flags/jvmFlag.hpp"
  33 #include "runtime/flags/jvmFlagConstraintList.hpp"
  34 #include "runtime/flags/jvmFlagRangeList.hpp"
  35 #include "runtime/globals_extension.hpp"
  36 #include "runtime/os.hpp"
  37 #include "runtime/task.hpp"

  38 #include "utilities/macros.hpp"
  39 









  40 class JVMFlagRange_int : public JVMFlagRange {
  41   int _min;
  42   int _max;
  43   const int* _ptr;
  44 
  45 public:
  46   // the "name" argument must be a string literal
  47   JVMFlagRange_int(const char* name, const int* ptr, int min, int max)
  48     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
  49 
  50   JVMFlag::Error check(bool verbose = true) {
  51     return check_int(*_ptr, verbose);
  52   }
  53 
  54   JVMFlag::Error check_int(int value, bool verbose = true) {
  55     if ((value < _min) || (value > _max)) {
  56       JVMFlag::printError(verbose,
  57                               "int %s=%d is outside the allowed range "
  58                               "[ %d ... %d ]\n",
  59                               name(), value, _min, _max);
  60       return JVMFlag::OUT_OF_BOUNDS;
  61     } else {
  62       return JVMFlag::SUCCESS;
  63     }
  64   }
  65 
  66   void print(outputStream* st) {
  67     st->print("[ %-25d ... %25d ]", _min, _max);
  68   }
  69 };
  70 
  71 class JVMFlagRange_intx : public JVMFlagRange {
  72   intx _min;
  73   intx _max;
  74   const intx* _ptr;
  75 public:
  76   // the "name" argument must be a string literal
  77   JVMFlagRange_intx(const char* name, const intx* ptr, intx min, intx max)
  78     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
  79 
  80   JVMFlag::Error check(bool verbose = true) {
  81     return check_intx(*_ptr, verbose);
  82   }
  83 
  84   JVMFlag::Error check_intx(intx value, bool verbose = true) {
  85     if ((value < _min) || (value > _max)) {
  86       JVMFlag::printError(verbose,
  87                               "intx %s=" INTX_FORMAT " is outside the allowed range "
  88                               "[ " INTX_FORMAT " ... " INTX_FORMAT " ]\n",
  89                               name(), value, _min, _max);
  90       return JVMFlag::OUT_OF_BOUNDS;
  91     } else {
  92       return JVMFlag::SUCCESS;
  93     }
  94   }
  95 
  96   void print(outputStream* st) {
  97     st->print("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", _min, _max);
  98   }
  99 };
 100 
 101 class JVMFlagRange_uint : public JVMFlagRange {
 102   uint _min;
 103   uint _max;
 104   const uint* _ptr;
 105 
 106 public:
 107   // the "name" argument must be a string literal
 108   JVMFlagRange_uint(const char* name, const uint* ptr, uint min, uint max)
 109     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 110 
 111   JVMFlag::Error check(bool verbose = true) {
 112     return check_uint(*_ptr, verbose);
 113   }
 114 
 115   JVMFlag::Error check_uint(uint value, bool verbose = true) {
 116     if ((value < _min) || (value > _max)) {
 117       JVMFlag::printError(verbose,
 118                               "uint %s=%u is outside the allowed range "
 119                               "[ %u ... %u ]\n",
 120                               name(), value, _min, _max);
 121       return JVMFlag::OUT_OF_BOUNDS;
 122     } else {
 123       return JVMFlag::SUCCESS;
 124     }
 125   }
 126 
 127   void print(outputStream* st) {
 128     st->print("[ %-25u ... %25u ]", _min, _max);
 129   }
 130 };
 131 
 132 class JVMFlagRange_uintx : public JVMFlagRange {
 133   uintx _min;
 134   uintx _max;
 135   const uintx* _ptr;
 136 
 137 public:
 138   // the "name" argument must be a string literal
 139   JVMFlagRange_uintx(const char* name, const uintx* ptr, uintx min, uintx max)
 140     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 141 
 142   JVMFlag::Error check(bool verbose = true) {
 143     return check_uintx(*_ptr, verbose);
 144   }
 145 
 146   JVMFlag::Error check_uintx(uintx value, bool verbose = true) {
 147     if ((value < _min) || (value > _max)) {
 148       JVMFlag::printError(verbose,
 149                               "uintx %s=" UINTX_FORMAT " is outside the allowed range "
 150                               "[ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n",
 151                               name(), value, _min, _max);
 152       return JVMFlag::OUT_OF_BOUNDS;
 153     } else {
 154       return JVMFlag::SUCCESS;
 155     }
 156   }
 157 
 158   void print(outputStream* st) {
 159     st->print("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", _min, _max);
 160   }
 161 };
 162 
 163 class JVMFlagRange_uint64_t : public JVMFlagRange {
 164   uint64_t _min;
 165   uint64_t _max;
 166   const uint64_t* _ptr;
 167 
 168 public:
 169   // the "name" argument must be a string literal
 170   JVMFlagRange_uint64_t(const char* name, const uint64_t* ptr, uint64_t min, uint64_t max)
 171     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 172 
 173   JVMFlag::Error check(bool verbose = true) {
 174     return check_uint64_t(*_ptr, verbose);
 175   }
 176 
 177   JVMFlag::Error check_uint64_t(uint64_t value, bool verbose = true) {
 178     if ((value < _min) || (value > _max)) {
 179       JVMFlag::printError(verbose,
 180                               "uint64_t %s=" UINT64_FORMAT " is outside the allowed range "
 181                               "[ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n",
 182                               name(), value, _min, _max);
 183       return JVMFlag::OUT_OF_BOUNDS;
 184     } else {
 185       return JVMFlag::SUCCESS;
 186     }
 187   }
 188 
 189   void print(outputStream* st) {
 190     st->print("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", _min, _max);
 191   }
 192 };
 193 
 194 class JVMFlagRange_size_t : public JVMFlagRange {
 195   size_t _min;
 196   size_t _max;
 197   const size_t* _ptr;
 198 
 199 public:
 200   // the "name" argument must be a string literal
 201   JVMFlagRange_size_t(const char* name, const size_t* ptr, size_t min, size_t max)
 202     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 203 
 204   JVMFlag::Error check(bool verbose = true) {
 205     return check_size_t(*_ptr, verbose);
 206   }
 207 
 208   JVMFlag::Error check_size_t(size_t value, bool verbose = true) {
 209     if ((value < _min) || (value > _max)) {
 210       JVMFlag::printError(verbose,
 211                               "size_t %s=" SIZE_FORMAT " is outside the allowed range "
 212                               "[ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n",
 213                               name(), value, _min, _max);
 214       return JVMFlag::OUT_OF_BOUNDS;
 215     } else {
 216       return JVMFlag::SUCCESS;
 217     }
 218   }
 219 
 220   void print(outputStream* st) {
 221     st->print("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", _min, _max);
 222   }
 223 };
 224 
 225 class JVMFlagRange_double : public JVMFlagRange {
 226   double _min;
 227   double _max;
 228   const double* _ptr;
 229 
 230 public:
 231   // the "name" argument must be a string literal
 232   JVMFlagRange_double(const char* name, const double* ptr, double min, double max)
 233     : JVMFlagRange(name), _min(min), _max(max), _ptr(ptr) {}
 234 
 235   JVMFlag::Error check(bool verbose = true) {
 236     return check_double(*_ptr, verbose);
 237   }
 238 
 239   JVMFlag::Error check_double(double value, bool verbose = true) {
 240     if ((value < _min) || (value > _max)) {
 241       JVMFlag::printError(verbose,
 242                               "double %s=%f is outside the allowed range "
 243                               "[ %f ... %f ]\n",
 244                               name(), value, _min, _max);
 245       return JVMFlag::OUT_OF_BOUNDS;
 246     } else {
 247       return JVMFlag::SUCCESS;
 248     }
 249   }
 250 
 251   void print(outputStream* st) {
 252     st->print("[ %-25.3f ... %25.3f ]", _min, _max);
 253   }
 254 };
 255 
 256 // No constraint emitting
 257 void emit_range_no(...)                         { /* NOP */ }
 258 
 259 // No constraint emitting if function argument is NOT provided
 260 void emit_range_bool(const char* /*name*/, const bool* /*value*/)            { /* NOP */ }
 261 void emit_range_ccstr(const char* /*name*/, const ccstr* /*value*/)          { /* NOP */ }


 405   }
 406   return found;
 407 }
 408 
 409 void JVMFlagRangeList::print(outputStream* st, const char* name, RangeStrFunc default_range_str_func) {
 410   JVMFlagRange* range = JVMFlagRangeList::find(name);
 411   if (range != NULL) {
 412     range->print(st);
 413   } else {
 414     JVMFlagConstraint* constraint = JVMFlagConstraintList::find(name);
 415     if (constraint != NULL) {
 416       assert(default_range_str_func!=NULL, "default_range_str_func must be provided");
 417       st->print("%s", default_range_str_func());
 418     } else {
 419       st->print("[                           ...                           ]");
 420     }
 421   }
 422 }
 423 
 424 bool JVMFlagRangeList::check_ranges() {

 425   bool status = true;
 426   for (int i=0; i<length(); i++) {
 427     JVMFlagRange* range = at(i);
 428     if (range->check(true) != JVMFlag::SUCCESS) status = false;
 429   }
 430   return status;
 431 }
< prev index next >