1 /*

     2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

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

   272 void emit_range_ccstrlist(const char* /*name*/, const ccstrlist* /*value*/)  { /* NOP */ }

   273 void emit_range_int(const char* /*name*/, const int* /*value*/)              { /* NOP */ }

   274 void emit_range_intx(const char* /*name*/, const intx* /*value*/)            { /* NOP */ }

   275 void emit_range_uint(const char* /*name*/, const uint* /*value*/)            { /* NOP */ }

   276 void emit_range_uintx(const char* /*name*/, const uintx* /*value*/)          { /* NOP */ }

   277 void emit_range_uint64_t(const char* /*name*/, const uint64_t* /*value*/)    { /* NOP */ }

   278 void emit_range_size_t(const char* /*name*/, const size_t* /*value*/)        { /* NOP */ }

   279 void emit_range_double(const char* /*name*/, const double* /*value*/)        { /* NOP */ }

   280 

   281 // JVMFlagRange emitting code functions if range arguments are provided

   282 void emit_range_int(const char* name, const int* ptr, int min, int max)       {

   283   JVMFlagRangeList::add(new JVMFlagRange_int(name, ptr, min, max));

   284 }

   285 void emit_range_intx(const char* name, const intx* ptr, intx min, intx max) {

   286   JVMFlagRangeList::add(new JVMFlagRange_intx(name, ptr, min, max));

   287 }

   288 void emit_range_uint(const char* name, const uint* ptr, uint min, uint max) {

   289   JVMFlagRangeList::add(new JVMFlagRange_uint(name, ptr, min, max));

   290 }

   291 void emit_range_uintx(const char* name, const uintx* ptr, uintx min, uintx max) {

   292   JVMFlagRangeList::add(new JVMFlagRange_uintx(name, ptr, min, max));

   293 }

   294 void emit_range_uint64_t(const char* name, const uint64_t* ptr, uint64_t min, uint64_t max) {

   295   JVMFlagRangeList::add(new JVMFlagRange_uint64_t(name, ptr, min, max));

   296 }

   297 void emit_range_size_t(const char* name, const size_t* ptr, size_t min, size_t max) {

   298   JVMFlagRangeList::add(new JVMFlagRange_size_t(name, ptr, min, max));

   299 }

   300 void emit_range_double(const char* name, const double* ptr, double min, double max) {

   301   JVMFlagRangeList::add(new JVMFlagRange_double(name, ptr, min, max));

   302 }

   303 

   304 // Generate code to call emit_range_xxx function

   305 #define EMIT_RANGE_PRODUCT_FLAG(type, name, value, doc)      ); emit_range_##type(#name,&name

   306 #define EMIT_RANGE_COMMERCIAL_FLAG(type, name, value, doc)   ); emit_range_##type(#name,&name

   307 #define EMIT_RANGE_DIAGNOSTIC_FLAG(type, name, value, doc)   ); emit_range_##type(#name,&name

   308 #define EMIT_RANGE_EXPERIMENTAL_FLAG(type, name, value, doc) ); emit_range_##type(#name,&name

   309 #define EMIT_RANGE_MANAGEABLE_FLAG(type, name, value, doc)   ); emit_range_##type(#name,&name

   310 #define EMIT_RANGE_PRODUCT_RW_FLAG(type, name, value, doc)   ); emit_range_##type(#name,&name

   311 #define EMIT_RANGE_PD_PRODUCT_FLAG(type, name, doc)          ); emit_range_##type(#name,&name

   312 #define EMIT_RANGE_PD_DIAGNOSTIC_FLAG(type, name, doc)       ); emit_range_##type(#name,&name

   313 #ifndef PRODUCT

   314 #define EMIT_RANGE_DEVELOPER_FLAG(type, name, value, doc)    ); emit_range_##type(#name,&name

   315 #define EMIT_RANGE_PD_DEVELOPER_FLAG(type, name, doc)        ); emit_range_##type(#name,&name

   316 #define EMIT_RANGE_NOTPRODUCT_FLAG(type, name, value, doc)   ); emit_range_##type(#name,&name

   317 #else

   318 #define EMIT_RANGE_DEVELOPER_FLAG(type, name, value, doc)    ); emit_range_no(#name,&name

   319 #define EMIT_RANGE_PD_DEVELOPER_FLAG(type, name, doc)        ); emit_range_no(#name,&name

   320 #define EMIT_RANGE_NOTPRODUCT_FLAG(type, name, value, doc)   ); emit_range_no(#name,&name

   321 #endif

   322 #ifdef _LP64

   323 #define EMIT_RANGE_LP64_PRODUCT_FLAG(type, name, value, doc) ); emit_range_##type(#name,&name

   324 #else

   325 #define EMIT_RANGE_LP64_PRODUCT_FLAG(type, name, value, doc) ); emit_range_no(#name,&name

   326 #endif

   327 

   328 // Generate func argument to pass into emit_range_xxx functions

   329 #define EMIT_RANGE_CHECK(a, b)                               , a, b

   330 

   331 #define INITIAL_RANGES_SIZE 379

   332 GrowableArray<JVMFlagRange*>* JVMFlagRangeList::_ranges = NULL;

   333 

   334 // Check the ranges of all flags that have them

   335 void JVMFlagRangeList::init(void) {

   336 

   337   _ranges = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<JVMFlagRange*>(INITIAL_RANGES_SIZE, true);

   338 

   339   emit_range_no(NULL VM_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,

   340                               EMIT_RANGE_PD_DEVELOPER_FLAG,

   341                               EMIT_RANGE_PRODUCT_FLAG,

   342                               EMIT_RANGE_PD_PRODUCT_FLAG,

   343                               EMIT_RANGE_DIAGNOSTIC_FLAG,

   344                               EMIT_RANGE_PD_DIAGNOSTIC_FLAG,

   345                               EMIT_RANGE_EXPERIMENTAL_FLAG,

   346                               EMIT_RANGE_NOTPRODUCT_FLAG,

   347                               EMIT_RANGE_MANAGEABLE_FLAG,

   348                               EMIT_RANGE_PRODUCT_RW_FLAG,

   349                               EMIT_RANGE_LP64_PRODUCT_FLAG,

   350                               EMIT_RANGE_CHECK,

   351                               IGNORE_CONSTRAINT,

   352                               IGNORE_WRITEABLE));

   353 

   354   EMIT_RANGES_FOR_GLOBALS_EXT

   355 

   356   emit_range_no(NULL ARCH_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,

   357                                 EMIT_RANGE_PRODUCT_FLAG,

   358                                 EMIT_RANGE_DIAGNOSTIC_FLAG,

   359                                 EMIT_RANGE_EXPERIMENTAL_FLAG,

   360                                 EMIT_RANGE_NOTPRODUCT_FLAG,

   361                                 EMIT_RANGE_CHECK,

   362                                 IGNORE_CONSTRAINT,

   363                                 IGNORE_WRITEABLE));

   364 

   365 #if INCLUDE_JVMCI

   366   emit_range_no(NULL JVMCI_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,

   367                                  EMIT_RANGE_PD_DEVELOPER_FLAG,

   368                                  EMIT_RANGE_PRODUCT_FLAG,

   369                                  EMIT_RANGE_PD_PRODUCT_FLAG,

   370                                  EMIT_RANGE_DIAGNOSTIC_FLAG,

   371                                  EMIT_RANGE_PD_DIAGNOSTIC_FLAG,

   372                                  EMIT_RANGE_EXPERIMENTAL_FLAG,

   373                                  EMIT_RANGE_NOTPRODUCT_FLAG,

   374                                  EMIT_RANGE_CHECK,

   375                                  IGNORE_CONSTRAINT,

   376                                  IGNORE_WRITEABLE));

   377 #endif // INCLUDE_JVMCI

   378 

   379 #ifdef COMPILER1

   380   emit_range_no(NULL C1_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,

   381                               EMIT_RANGE_PD_DEVELOPER_FLAG,

   382                               EMIT_RANGE_PRODUCT_FLAG,

   383                               EMIT_RANGE_PD_PRODUCT_FLAG,

   384                               EMIT_RANGE_DIAGNOSTIC_FLAG,

   385                               EMIT_RANGE_PD_DIAGNOSTIC_FLAG,

   386                               EMIT_RANGE_NOTPRODUCT_FLAG,

   387                               EMIT_RANGE_CHECK,

   388                               IGNORE_CONSTRAINT,

   389                               IGNORE_WRITEABLE));

   390 #endif // COMPILER1

   391 

   392 #ifdef COMPILER2

   393   emit_range_no(NULL C2_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,

   394                               EMIT_RANGE_PD_DEVELOPER_FLAG,

   395                               EMIT_RANGE_PRODUCT_FLAG,

   396                               EMIT_RANGE_PD_PRODUCT_FLAG,

   397                               EMIT_RANGE_DIAGNOSTIC_FLAG,

   398                               EMIT_RANGE_PD_DIAGNOSTIC_FLAG,

   399                               EMIT_RANGE_EXPERIMENTAL_FLAG,

   400                               EMIT_RANGE_NOTPRODUCT_FLAG,

   401                               EMIT_RANGE_CHECK,

   402                               IGNORE_CONSTRAINT,

   403                               IGNORE_WRITEABLE));

   404 #endif // COMPILER2

   405 }

   406 

   407 JVMFlagRange* JVMFlagRangeList::find(const char* name) {

   408   JVMFlagRange* found = NULL;

   409   for (int i=0; i<length(); i++) {

   410     JVMFlagRange* range = at(i);

   411     if (strcmp(range->name(), name) == 0) {

   412       found = range;

   413       break;

   414     }

   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 }