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