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 "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "gc/shared/referenceProcessor.hpp"
29 #include "runtime/arguments.hpp"
30 #include "runtime/commandLineFlagRangeList.hpp"
31 #include "runtime/os.hpp"
32 #include "utilities/defaultStream.hpp"
33 #include "utilities/macros.hpp"
34
35 class CommandLineFlagRange_int : public CommandLineFlagRange {
36 int _min;
37 int _max;
38
39 public:
40 // the "name" argument must be a string literal
41 CommandLineFlagRange_int(const char* name, int min, int max) : CommandLineFlagRange(name) {
42 _min=min, _max=max;
43 }
44
45 Flag::Error check_int(int value, bool verbose = true) {
46 if ((value < _min) || (value > _max)) {
47 if (verbose == true) {
48 jio_fprintf(defaultStream::error_stream(),
49 "int %s=%d is outside the allowed range [ %d ... %d ]\n",
50 name(), value, _min, _max);
51 }
52 return Flag::OUT_OF_BOUNDS;
53 } else {
54 return Flag::SUCCESS;
55 }
56 }
57
58 void print(outputStream* st) {
59 st->print("[ %-25d ... %25d ]", _min, _max);
60 }
61 };
62
63 class CommandLineFlagRange_intx : public CommandLineFlagRange {
64 intx _min;
65 intx _max;
66
67 public:
68 // the "name" argument must be a string literal
69 CommandLineFlagRange_intx(const char* name, intx min, intx max) : CommandLineFlagRange(name) {
70 _min=min, _max=max;
71 }
72
73 Flag::Error check_intx(intx value, bool verbose = true) {
74 if ((value < _min) || (value > _max)) {
75 if (verbose == true) {
76 jio_fprintf(defaultStream::error_stream(),
77 "intx %s=" INTX_FORMAT " is outside the allowed range [ " INTX_FORMAT " ... " INTX_FORMAT " ]\n",
78 name(), value, _min, _max);
79 }
80 return Flag::OUT_OF_BOUNDS;
81 } else {
82 return Flag::SUCCESS;
83 }
84 }
85
86 void print(outputStream* st) {
87 st->print("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", _min, _max);
88 }
89 };
90
91 class CommandLineFlagRange_uint : public CommandLineFlagRange {
92 uint _min;
93 uint _max;
94
95 public:
96 // the "name" argument must be a string literal
97 CommandLineFlagRange_uint(const char* name, uint min, uint max) : CommandLineFlagRange(name) {
98 _min=min, _max=max;
99 }
100
101 Flag::Error check_uint(uint value, bool verbose = true) {
102 if ((value < _min) || (value > _max)) {
103 if (verbose == true) {
104 jio_fprintf(defaultStream::error_stream(),
105 "uintx %s=%u is outside the allowed range [ %u ... %u ]\n",
106 name(), value, _min, _max);
107 }
108 return Flag::OUT_OF_BOUNDS;
109 } else {
110 return Flag::SUCCESS;
111 }
112 }
113
114 void print(outputStream* st) {
115 st->print("[ %-25u ... %25u ]", _min, _max);
116 }
117 };
118
119 class CommandLineFlagRange_uintx : public CommandLineFlagRange {
120 uintx _min;
121 uintx _max;
122
123 public:
124 // the "name" argument must be a string literal
125 CommandLineFlagRange_uintx(const char* name, uintx min, uintx max) : CommandLineFlagRange(name) {
126 _min=min, _max=max;
127 }
128
129 Flag::Error check_uintx(uintx value, bool verbose = true) {
130 if ((value < _min) || (value > _max)) {
131 if (verbose == true) {
132 jio_fprintf(defaultStream::error_stream(),
133 "uintx %s=" UINTX_FORMAT " is outside the allowed range [ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n",
134 name(), value, _min, _max);
135 }
136 return Flag::OUT_OF_BOUNDS;
137 } else {
138 return Flag::SUCCESS;
139 }
140 }
141
142 void print(outputStream* st) {
143 st->print("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", _min, _max);
144 }
145 };
146
147 class CommandLineFlagRange_uint64_t : public CommandLineFlagRange {
148 uint64_t _min;
149 uint64_t _max;
150
151 public:
152 // the "name" argument must be a string literal
153 CommandLineFlagRange_uint64_t(const char* name, uint64_t min, uint64_t max) : CommandLineFlagRange(name) {
154 _min=min, _max=max;
155 }
156
157 Flag::Error check_uint64_t(uint64_t value, bool verbose = true) {
158 if ((value < _min) || (value > _max)) {
159 if (verbose == true) {
160 jio_fprintf(defaultStream::error_stream(),
161 "uint64_t %s=" UINT64_FORMAT " is outside the allowed range [ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n",
162 name(), value, _min, _max);
163 }
164 return Flag::OUT_OF_BOUNDS;
165 } else {
166 return Flag::SUCCESS;
167 }
168 }
169
170 void print(outputStream* st) {
171 st->print("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", _min, _max);
172 }
173 };
174
175 class CommandLineFlagRange_size_t : public CommandLineFlagRange {
176 size_t _min;
177 size_t _max;
178
179 public:
180 // the "name" argument must be a string literal
181 CommandLineFlagRange_size_t(const char* name, size_t min, size_t max) : CommandLineFlagRange(name) {
182 _min=min, _max=max;
183 }
184
185 Flag::Error check_size_t(size_t value, bool verbose = true) {
186 if ((value < _min) || (value > _max)) {
187 if (verbose == true) {
188 jio_fprintf(defaultStream::error_stream(),
189 "size_t %s=" SIZE_FORMAT " is outside the allowed range [ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n",
190 name(), value, _min, _max);
191 }
192 return Flag::OUT_OF_BOUNDS;
193 } else {
194 return Flag::SUCCESS;
195 }
196 }
197
198 void print(outputStream* st) {
199 st->print("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", _min, _max);
200 }
201 };
202
203 class CommandLineFlagRange_double : public CommandLineFlagRange {
204 double _min;
205 double _max;
206
207 public:
208 // the "name" argument must be a string literal
209 CommandLineFlagRange_double(const char* name, double min, double max) : CommandLineFlagRange(name) {
210 _min=min, _max=max;
211 }
212
213 Flag::Error check_double(double value, bool verbose = true) {
214 if ((value < _min) || (value > _max)) {
215 if (verbose == true) {
216 jio_fprintf(defaultStream::error_stream(),
217 "double %s=%f is outside the allowed range [ %f ... %f ]\n",
218 name(), value, _min, _max);
219 }
220 return Flag::OUT_OF_BOUNDS;
221 } else {
222 return Flag::SUCCESS;
223 }
224 }
225
226 void print(outputStream* st) {
227 st->print("[ %-25.3f ... %25.3f ]", _min, _max);
228 }
229 };
230
231 // No constraint emitting
232 void emit_range_no(...) { /* NOP */ }
233
234 // No constraint emitting if function argument is NOT provided
235 void emit_range_bool(const char* /*name*/) { /* NOP */ }
236 void emit_range_ccstr(const char* /*name*/) { /* NOP */ }
237 void emit_range_ccstrlist(const char* /*name*/) { /* NOP */ }
238 void emit_range_int(const char* /*name*/) { /* NOP */ }
239 void emit_range_intx(const char* /*name*/) { /* NOP */ }
350 for (int i=0; i<length(); i++) {
351 CommandLineFlagRange* range = at(i);
352 if (strcmp(range->name(), name) == 0) {
353 found = range;
354 break;
355 }
356 }
357 return found;
358 }
359
360 void CommandLineFlagRangeList::print(const char* name, outputStream* st, bool unspecified) {
361 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
362 if (range != NULL) {
363 range->print(st);
364 } else if (unspecified == true) {
365 st->print("[ ... ]");
366 }
367 }
368
369 bool CommandLineFlagRangeList::check_ranges() {
370 //#define PRINT_RANGES_SIZES
371 #ifdef PRINT_RANGES_SIZES
372 {
373 size_t size_ranges = sizeof(CommandLineFlagRangeList);
374 for (int i=0; i<length(); i++) {
375 size_ranges += sizeof(CommandLineFlagRange);
376 CommandLineFlagRange* range = at(i);
377 const char* name = range->name();
378 Flag* flag = Flag::find_flag(name, strlen(name), true, true);
379 if (flag->is_intx()) {
380 size_ranges += 2*sizeof(intx);
381 size_ranges += sizeof(CommandLineFlagRange*);
382 } else if (flag->is_uintx()) {
383 size_ranges += 2*sizeof(uintx);
384 size_ranges += sizeof(CommandLineFlagRange*);
385 } else if (flag->is_uint64_t()) {
386 size_ranges += 2*sizeof(uint64_t);
387 size_ranges += sizeof(CommandLineFlagRange*);
388 } else if (flag->is_size_t()) {
389 size_ranges += 2*sizeof(size_t);
390 size_ranges += sizeof(CommandLineFlagRange*);
391 } else if (flag->is_double()) {
392 size_ranges += 2*sizeof(double);
393 size_ranges += sizeof(CommandLineFlagRange*);
394 }
395 }
396 fprintf(stderr, "Size of %d ranges: " SIZE_FORMAT " bytes\n",
397 length(), size_ranges);
398 }
399 #endif // PRINT_RANGES_SIZES
400
401 // Check ranges.
402 bool status = true;
403 for (int i=0; i<length(); i++) {
404 CommandLineFlagRange* range = at(i);
405 const char* name = range->name();
406 Flag* flag = Flag::find_flag(name, strlen(name), true, true);
407 if (flag != NULL) {
408 if (flag->is_intx()) {
409 intx value = flag->get_intx();
410 if (range->check_intx(value, true) != Flag::SUCCESS) status = false;
411 } else if (flag->is_uintx()) {
412 uintx value = flag->get_uintx();
413 if (range->check_uintx(value, true) != Flag::SUCCESS) status = false;
414 } else if (flag->is_uint64_t()) {
415 uint64_t value = flag->get_uint64_t();
416 if (range->check_uint64_t(value, true) != Flag::SUCCESS) status = false;
417 } else if (flag->is_size_t()) {
418 size_t value = flag->get_size_t();
419 if (range->check_size_t(value, true) != Flag::SUCCESS) status = false;
420 } else if (flag->is_double()) {
421 double value = flag->get_double();
422 if (range->check_double(value, true) != Flag::SUCCESS) status = false;
423 }
424 }
425 }
426 return status;
|
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 "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "gc/shared/referenceProcessor.hpp"
29 #include "runtime/arguments.hpp"
30 #include "runtime/commandLineFlagRangeList.hpp"
31 #include "runtime/os.hpp"
32 #include "utilities/defaultStream.hpp"
33 #include "utilities/macros.hpp"
34
35 void CommandLineError::print(bool verbose, const char* msg, ...) {
36 if (verbose) {
37 va_list listPointer;
38 va_start(listPointer, msg);
39 jio_vfprintf(defaultStream::error_stream(), msg, listPointer);
40 va_end(listPointer);
41 }
42 }
43
44 class CommandLineFlagRange_int : public CommandLineFlagRange {
45 int _min;
46 int _max;
47
48 public:
49 // the "name" argument must be a string literal
50 CommandLineFlagRange_int(const char* name, int min, int max) : CommandLineFlagRange(name) {
51 _min=min, _max=max;
52 }
53
54 Flag::Error check_int(int value, bool verbose = true) {
55 if ((value < _min) || (value > _max)) {
56 CommandLineError::print(verbose,
57 "int %s=%d is outside the allowed range "
58 "[ %d ... %d ]\n",
59 name(), value, _min, _max);
60 return Flag::OUT_OF_BOUNDS;
61 } else {
62 return Flag::SUCCESS;
63 }
64 }
65
66 void print(outputStream* st) {
67 st->print("[ %-25d ... %25d ]", _min, _max);
68 }
69 };
70
71 class CommandLineFlagRange_intx : public CommandLineFlagRange {
72 intx _min;
73 intx _max;
74
75 public:
76 // the "name" argument must be a string literal
77 CommandLineFlagRange_intx(const char* name, intx min, intx max) : CommandLineFlagRange(name) {
78 _min=min, _max=max;
79 }
80
81 Flag::Error check_intx(intx value, bool verbose = true) {
82 if ((value < _min) || (value > _max)) {
83 CommandLineError::print(verbose,
84 "intx %s=" INTX_FORMAT " is outside the allowed range "
85 "[ " INTX_FORMAT " ... " INTX_FORMAT " ]\n",
86 name(), value, _min, _max);
87 return Flag::OUT_OF_BOUNDS;
88 } else {
89 return Flag::SUCCESS;
90 }
91 }
92
93 void print(outputStream* st) {
94 st->print("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", _min, _max);
95 }
96 };
97
98 class CommandLineFlagRange_uint : public CommandLineFlagRange {
99 uint _min;
100 uint _max;
101
102 public:
103 // the "name" argument must be a string literal
104 CommandLineFlagRange_uint(const char* name, uint min, uint max) : CommandLineFlagRange(name) {
105 _min=min, _max=max;
106 }
107
108 Flag::Error check_uint(uint value, bool verbose = true) {
109 if ((value < _min) || (value > _max)) {
110 CommandLineError::print(verbose,
111 "uint %s=%u is outside the allowed range "
112 "[ %u ... %u ]\n",
113 name(), value, _min, _max);
114 return Flag::OUT_OF_BOUNDS;
115 } else {
116 return Flag::SUCCESS;
117 }
118 }
119
120 void print(outputStream* st) {
121 st->print("[ %-25u ... %25u ]", _min, _max);
122 }
123 };
124
125 class CommandLineFlagRange_uintx : public CommandLineFlagRange {
126 uintx _min;
127 uintx _max;
128
129 public:
130 // the "name" argument must be a string literal
131 CommandLineFlagRange_uintx(const char* name, uintx min, uintx max) : CommandLineFlagRange(name) {
132 _min=min, _max=max;
133 }
134
135 Flag::Error check_uintx(uintx value, bool verbose = true) {
136 if ((value < _min) || (value > _max)) {
137 CommandLineError::print(verbose,
138 "uintx %s=" UINTX_FORMAT " is outside the allowed range "
139 "[ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n",
140 name(), value, _min, _max);
141 return Flag::OUT_OF_BOUNDS;
142 } else {
143 return Flag::SUCCESS;
144 }
145 }
146
147 void print(outputStream* st) {
148 st->print("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", _min, _max);
149 }
150 };
151
152 class CommandLineFlagRange_uint64_t : public CommandLineFlagRange {
153 uint64_t _min;
154 uint64_t _max;
155
156 public:
157 // the "name" argument must be a string literal
158 CommandLineFlagRange_uint64_t(const char* name, uint64_t min, uint64_t max) : CommandLineFlagRange(name) {
159 _min=min, _max=max;
160 }
161
162 Flag::Error check_uint64_t(uint64_t value, bool verbose = true) {
163 if ((value < _min) || (value > _max)) {
164 CommandLineError::print(verbose,
165 "uint64_t %s=" UINT64_FORMAT " is outside the allowed range "
166 "[ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n",
167 name(), value, _min, _max);
168 return Flag::OUT_OF_BOUNDS;
169 } else {
170 return Flag::SUCCESS;
171 }
172 }
173
174 void print(outputStream* st) {
175 st->print("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", _min, _max);
176 }
177 };
178
179 class CommandLineFlagRange_size_t : public CommandLineFlagRange {
180 size_t _min;
181 size_t _max;
182
183 public:
184 // the "name" argument must be a string literal
185 CommandLineFlagRange_size_t(const char* name, size_t min, size_t max) : CommandLineFlagRange(name) {
186 _min=min, _max=max;
187 }
188
189 Flag::Error check_size_t(size_t value, bool verbose = true) {
190 if ((value < _min) || (value > _max)) {
191 CommandLineError::print(verbose,
192 "size_t %s=" SIZE_FORMAT " is outside the allowed range "
193 "[ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n",
194 name(), value, _min, _max);
195 return Flag::OUT_OF_BOUNDS;
196 } else {
197 return Flag::SUCCESS;
198 }
199 }
200
201 void print(outputStream* st) {
202 st->print("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", _min, _max);
203 }
204 };
205
206 class CommandLineFlagRange_double : public CommandLineFlagRange {
207 double _min;
208 double _max;
209
210 public:
211 // the "name" argument must be a string literal
212 CommandLineFlagRange_double(const char* name, double min, double max) : CommandLineFlagRange(name) {
213 _min=min, _max=max;
214 }
215
216 Flag::Error check_double(double value, bool verbose = true) {
217 if ((value < _min) || (value > _max)) {
218 CommandLineError::print(verbose,
219 "double %s=%f is outside the allowed range "
220 "[ %f ... %f ]\n",
221 name(), value, _min, _max);
222 return Flag::OUT_OF_BOUNDS;
223 } else {
224 return Flag::SUCCESS;
225 }
226 }
227
228 void print(outputStream* st) {
229 st->print("[ %-25.3f ... %25.3f ]", _min, _max);
230 }
231 };
232
233 // No constraint emitting
234 void emit_range_no(...) { /* NOP */ }
235
236 // No constraint emitting if function argument is NOT provided
237 void emit_range_bool(const char* /*name*/) { /* NOP */ }
238 void emit_range_ccstr(const char* /*name*/) { /* NOP */ }
239 void emit_range_ccstrlist(const char* /*name*/) { /* NOP */ }
240 void emit_range_int(const char* /*name*/) { /* NOP */ }
241 void emit_range_intx(const char* /*name*/) { /* NOP */ }
352 for (int i=0; i<length(); i++) {
353 CommandLineFlagRange* range = at(i);
354 if (strcmp(range->name(), name) == 0) {
355 found = range;
356 break;
357 }
358 }
359 return found;
360 }
361
362 void CommandLineFlagRangeList::print(const char* name, outputStream* st, bool unspecified) {
363 CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
364 if (range != NULL) {
365 range->print(st);
366 } else if (unspecified == true) {
367 st->print("[ ... ]");
368 }
369 }
370
371 bool CommandLineFlagRangeList::check_ranges() {
372 // Check ranges.
373 bool status = true;
374 for (int i=0; i<length(); i++) {
375 CommandLineFlagRange* range = at(i);
376 const char* name = range->name();
377 Flag* flag = Flag::find_flag(name, strlen(name), true, true);
378 // We must check for NULL here as lp64_product flags on 32 bit architecture
379 // can generate range check (despite that they are declared as constants),
380 // but they will not be returned by Flag::find_flag()
381 if (flag != NULL) {
382 if (flag->is_intx()) {
383 intx value = flag->get_intx();
384 if (range->check_intx(value, true) != Flag::SUCCESS) status = false;
385 } else if (flag->is_uintx()) {
386 uintx value = flag->get_uintx();
387 if (range->check_uintx(value, true) != Flag::SUCCESS) status = false;
388 } else if (flag->is_uint64_t()) {
389 uint64_t value = flag->get_uint64_t();
390 if (range->check_uint64_t(value, true) != Flag::SUCCESS) status = false;
391 } else if (flag->is_size_t()) {
392 size_t value = flag->get_size_t();
393 if (range->check_size_t(value, true) != Flag::SUCCESS) status = false;
394 } else if (flag->is_double()) {
395 double value = flag->get_double();
396 if (range->check_double(value, true) != Flag::SUCCESS) status = false;
397 }
398 }
399 }
400 return status;
|