115 return JVMFlag::VIOLATES_CONSTRAINT;
116 }
117
118 return JVMFlag::SUCCESS;
119 }
120
121 JVMFlag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose) {
122 if (AllocatePrefetchStyle == 3) {
123 if (value % wordSize != 0) {
124 JVMFlag::printError(verbose,
125 "AllocatePrefetchStepSize (" INTX_FORMAT ") must be multiple of %d\n",
126 value, wordSize);
127 return JVMFlag::VIOLATES_CONSTRAINT;
128 }
129 }
130 return JVMFlag::SUCCESS;
131 }
132
133 JVMFlag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose) {
134 intx max_value = max_intx;
135 #if defined(SPARC)
136 max_value = 1;
137 #elif defined(X86)
138 max_value = 3;
139 #endif
140 if (value < 0 || value > max_value) {
141 JVMFlag::printError(verbose,
142 "AllocatePrefetchInstr (" INTX_FORMAT ") must be "
143 "between 0 and " INTX_FORMAT "\n", value, max_value);
144 return JVMFlag::VIOLATES_CONSTRAINT;
145 }
146
147 return JVMFlag::SUCCESS;
148 }
149
150 JVMFlag::Error CompileThresholdConstraintFunc(intx value, bool verbose) {
151 if (value < 0 || value > INT_MAX >> InvocationCounter::count_shift) {
152 JVMFlag::printError(verbose,
153 "CompileThreshold (" INTX_FORMAT ") "
154 "must be between 0 and %d\n",
155 value,
156 INT_MAX >> InvocationCounter::count_shift);
157 return JVMFlag::VIOLATES_CONSTRAINT;
219 "at least " SIZE_FORMAT " to align constants\n",
220 CodeCacheSegmentSize, sizeof(jdouble));
221 return JVMFlag::VIOLATES_CONSTRAINT;
222 }
223
224 #ifdef COMPILER2
225 if (CodeCacheSegmentSize < (uintx)OptoLoopAlignment) {
226 JVMFlag::printError(verbose,
227 "CodeCacheSegmentSize (" UINTX_FORMAT ") must be "
228 "larger than or equal to OptoLoopAlignment (" INTX_FORMAT ") "
229 "to align inner loops\n",
230 CodeCacheSegmentSize, OptoLoopAlignment);
231 return JVMFlag::VIOLATES_CONSTRAINT;
232 }
233 #endif
234
235 return JVMFlag::SUCCESS;
236 }
237
238 JVMFlag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose) {
239 #ifdef SOLARIS
240 if ((value < MinimumPriority || value > MaximumPriority) &&
241 (value != -1) && (value != -FXCriticalPriority)) {
242 JVMFlag::printError(verbose,
243 "CompileThreadPriority (" INTX_FORMAT ") must be "
244 "between %d and %d inclusively or -1 (means no change) "
245 "or %d (special value for critical thread class/priority)\n",
246 value, MinimumPriority, MaximumPriority, -FXCriticalPriority);
247 return JVMFlag::VIOLATES_CONSTRAINT;
248 }
249 #endif
250
251 return JVMFlag::SUCCESS;
252 }
253
254 JVMFlag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose) {
255 #ifdef SPARC
256 if (CodeEntryAlignment % relocInfo::addr_unit() != 0) {
257 JVMFlag::printError(verbose,
258 "CodeEntryAlignment (" INTX_FORMAT ") must be "
259 "multiple of NOP size\n", CodeEntryAlignment);
260 return JVMFlag::VIOLATES_CONSTRAINT;
261 }
262 #endif
263
264 if (!is_power_of_2(value)) {
265 JVMFlag::printError(verbose,
266 "CodeEntryAlignment (" INTX_FORMAT ") must be "
267 "a power of two\n", CodeEntryAlignment);
268 return JVMFlag::VIOLATES_CONSTRAINT;
269 }
270
271 if (CodeEntryAlignment < 16) {
272 JVMFlag::printError(verbose,
273 "CodeEntryAlignment (" INTX_FORMAT ") must be "
274 "greater than or equal to %d\n",
275 CodeEntryAlignment, 16);
276 return JVMFlag::VIOLATES_CONSTRAINT;
277 }
278
279 return JVMFlag::SUCCESS;
280 }
281
282 JVMFlag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose) {
283 if (!is_power_of_2(value)) {
284 JVMFlag::printError(verbose,
285 "OptoLoopAlignment (" INTX_FORMAT ") "
286 "must be a power of two\n",
287 value);
288 return JVMFlag::VIOLATES_CONSTRAINT;
289 }
290
291 // Relevant on ppc, s390, sparc. Will be optimized where
292 // addr_unit() == 1.
293 if (OptoLoopAlignment % relocInfo::addr_unit() != 0) {
294 JVMFlag::printError(verbose,
295 "OptoLoopAlignment (" INTX_FORMAT ") must be "
296 "multiple of NOP size (%d)\n",
297 value, relocInfo::addr_unit());
298 return JVMFlag::VIOLATES_CONSTRAINT;
299 }
300
301 return JVMFlag::SUCCESS;
302 }
303
304 JVMFlag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose) {
305 if (value >= 4032) {
306 JVMFlag::printError(verbose,
307 "ArraycopyDstPrefetchDistance (" UINTX_FORMAT ") must be"
308 "between 0 and 4031\n", value);
309 return JVMFlag::VIOLATES_CONSTRAINT;
310 }
311
338 }
339
340 JVMFlag::Error InitArrayShortSizeConstraintFunc(intx value, bool verbose) {
341 if (value % BytesPerLong != 0) {
342 return JVMFlag::VIOLATES_CONSTRAINT;
343 } else {
344 return JVMFlag::SUCCESS;
345 }
346 }
347
348 #ifdef COMPILER2
349 JVMFlag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose) {
350 if (InteriorEntryAlignment > CodeEntryAlignment) {
351 JVMFlag::printError(verbose,
352 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
353 "less than or equal to CodeEntryAlignment (" INTX_FORMAT ")\n",
354 InteriorEntryAlignment, CodeEntryAlignment);
355 return JVMFlag::VIOLATES_CONSTRAINT;
356 }
357
358 #ifdef SPARC
359 if (InteriorEntryAlignment % relocInfo::addr_unit() != 0) {
360 JVMFlag::printError(verbose,
361 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
362 "multiple of NOP size\n");
363 return JVMFlag::VIOLATES_CONSTRAINT;
364 }
365 #endif
366
367 if (!is_power_of_2(value)) {
368 JVMFlag::printError(verbose,
369 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
370 "a power of two\n", InteriorEntryAlignment);
371 return JVMFlag::VIOLATES_CONSTRAINT;
372 }
373
374 int minimum_alignment = 16;
375 #if defined(SPARC) || (defined(X86) && !defined(AMD64))
376 minimum_alignment = 4;
377 #elif defined(S390)
378 minimum_alignment = 2;
379 #endif
380
381 if (InteriorEntryAlignment < minimum_alignment) {
382 JVMFlag::printError(verbose,
383 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
384 "greater than or equal to %d\n",
385 InteriorEntryAlignment, minimum_alignment);
386 return JVMFlag::VIOLATES_CONSTRAINT;
387 }
388
389 return JVMFlag::SUCCESS;
390 }
391
392 JVMFlag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose) {
393 if (value < MaxNodeLimit * 2 / 100 || value > MaxNodeLimit * 40 / 100) {
394 JVMFlag::printError(verbose,
395 "NodeLimitFudgeFactor must be between 2%% and 40%% "
|
115 return JVMFlag::VIOLATES_CONSTRAINT;
116 }
117
118 return JVMFlag::SUCCESS;
119 }
120
121 JVMFlag::Error AllocatePrefetchStepSizeConstraintFunc(intx value, bool verbose) {
122 if (AllocatePrefetchStyle == 3) {
123 if (value % wordSize != 0) {
124 JVMFlag::printError(verbose,
125 "AllocatePrefetchStepSize (" INTX_FORMAT ") must be multiple of %d\n",
126 value, wordSize);
127 return JVMFlag::VIOLATES_CONSTRAINT;
128 }
129 }
130 return JVMFlag::SUCCESS;
131 }
132
133 JVMFlag::Error AllocatePrefetchInstrConstraintFunc(intx value, bool verbose) {
134 intx max_value = max_intx;
135 #if defined(X86)
136 max_value = 3;
137 #endif
138 if (value < 0 || value > max_value) {
139 JVMFlag::printError(verbose,
140 "AllocatePrefetchInstr (" INTX_FORMAT ") must be "
141 "between 0 and " INTX_FORMAT "\n", value, max_value);
142 return JVMFlag::VIOLATES_CONSTRAINT;
143 }
144
145 return JVMFlag::SUCCESS;
146 }
147
148 JVMFlag::Error CompileThresholdConstraintFunc(intx value, bool verbose) {
149 if (value < 0 || value > INT_MAX >> InvocationCounter::count_shift) {
150 JVMFlag::printError(verbose,
151 "CompileThreshold (" INTX_FORMAT ") "
152 "must be between 0 and %d\n",
153 value,
154 INT_MAX >> InvocationCounter::count_shift);
155 return JVMFlag::VIOLATES_CONSTRAINT;
217 "at least " SIZE_FORMAT " to align constants\n",
218 CodeCacheSegmentSize, sizeof(jdouble));
219 return JVMFlag::VIOLATES_CONSTRAINT;
220 }
221
222 #ifdef COMPILER2
223 if (CodeCacheSegmentSize < (uintx)OptoLoopAlignment) {
224 JVMFlag::printError(verbose,
225 "CodeCacheSegmentSize (" UINTX_FORMAT ") must be "
226 "larger than or equal to OptoLoopAlignment (" INTX_FORMAT ") "
227 "to align inner loops\n",
228 CodeCacheSegmentSize, OptoLoopAlignment);
229 return JVMFlag::VIOLATES_CONSTRAINT;
230 }
231 #endif
232
233 return JVMFlag::SUCCESS;
234 }
235
236 JVMFlag::Error CompilerThreadPriorityConstraintFunc(intx value, bool verbose) {
237 return JVMFlag::SUCCESS;
238 }
239
240 JVMFlag::Error CodeEntryAlignmentConstraintFunc(intx value, bool verbose) {
241 if (!is_power_of_2(value)) {
242 JVMFlag::printError(verbose,
243 "CodeEntryAlignment (" INTX_FORMAT ") must be "
244 "a power of two\n", CodeEntryAlignment);
245 return JVMFlag::VIOLATES_CONSTRAINT;
246 }
247
248 if (CodeEntryAlignment < 16) {
249 JVMFlag::printError(verbose,
250 "CodeEntryAlignment (" INTX_FORMAT ") must be "
251 "greater than or equal to %d\n",
252 CodeEntryAlignment, 16);
253 return JVMFlag::VIOLATES_CONSTRAINT;
254 }
255
256 return JVMFlag::SUCCESS;
257 }
258
259 JVMFlag::Error OptoLoopAlignmentConstraintFunc(intx value, bool verbose) {
260 if (!is_power_of_2(value)) {
261 JVMFlag::printError(verbose,
262 "OptoLoopAlignment (" INTX_FORMAT ") "
263 "must be a power of two\n",
264 value);
265 return JVMFlag::VIOLATES_CONSTRAINT;
266 }
267
268 // Relevant on ppc, s390. Will be optimized where
269 // addr_unit() == 1.
270 if (OptoLoopAlignment % relocInfo::addr_unit() != 0) {
271 JVMFlag::printError(verbose,
272 "OptoLoopAlignment (" INTX_FORMAT ") must be "
273 "multiple of NOP size (%d)\n",
274 value, relocInfo::addr_unit());
275 return JVMFlag::VIOLATES_CONSTRAINT;
276 }
277
278 return JVMFlag::SUCCESS;
279 }
280
281 JVMFlag::Error ArraycopyDstPrefetchDistanceConstraintFunc(uintx value, bool verbose) {
282 if (value >= 4032) {
283 JVMFlag::printError(verbose,
284 "ArraycopyDstPrefetchDistance (" UINTX_FORMAT ") must be"
285 "between 0 and 4031\n", value);
286 return JVMFlag::VIOLATES_CONSTRAINT;
287 }
288
315 }
316
317 JVMFlag::Error InitArrayShortSizeConstraintFunc(intx value, bool verbose) {
318 if (value % BytesPerLong != 0) {
319 return JVMFlag::VIOLATES_CONSTRAINT;
320 } else {
321 return JVMFlag::SUCCESS;
322 }
323 }
324
325 #ifdef COMPILER2
326 JVMFlag::Error InteriorEntryAlignmentConstraintFunc(intx value, bool verbose) {
327 if (InteriorEntryAlignment > CodeEntryAlignment) {
328 JVMFlag::printError(verbose,
329 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
330 "less than or equal to CodeEntryAlignment (" INTX_FORMAT ")\n",
331 InteriorEntryAlignment, CodeEntryAlignment);
332 return JVMFlag::VIOLATES_CONSTRAINT;
333 }
334
335 if (!is_power_of_2(value)) {
336 JVMFlag::printError(verbose,
337 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
338 "a power of two\n", InteriorEntryAlignment);
339 return JVMFlag::VIOLATES_CONSTRAINT;
340 }
341
342 int minimum_alignment = 16;
343 #if defined(X86) && !defined(AMD64)
344 minimum_alignment = 4;
345 #elif defined(S390)
346 minimum_alignment = 2;
347 #endif
348
349 if (InteriorEntryAlignment < minimum_alignment) {
350 JVMFlag::printError(verbose,
351 "InteriorEntryAlignment (" INTX_FORMAT ") must be "
352 "greater than or equal to %d\n",
353 InteriorEntryAlignment, minimum_alignment);
354 return JVMFlag::VIOLATES_CONSTRAINT;
355 }
356
357 return JVMFlag::SUCCESS;
358 }
359
360 JVMFlag::Error NodeLimitFudgeFactorConstraintFunc(intx value, bool verbose) {
361 if (value < MaxNodeLimit * 2 / 100 || value > MaxNodeLimit * 40 / 100) {
362 JVMFlag::printError(verbose,
363 "NodeLimitFudgeFactor must be between 2%% and 40%% "
|