package org.graalvm.compiler.core.common;
import java.util.*;
import org.graalvm.compiler.options.*;
import org.graalvm.compiler.options.OptionType;
public class GraalOptions_OptionDescriptors implements OptionDescriptors {
@Override
public OptionDescriptor get(String value) {
switch (value) {
case "AlwaysInlineVTableStubs": {
return OptionDescriptor.create(
"AlwaysInlineVTableStubs",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"AlwaysInlineVTableStubs",
GraalOptions.AlwaysInlineVTableStubs);
}
case "CallArrayCopy": {
return OptionDescriptor.create(
"CallArrayCopy",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"CallArrayCopy",
GraalOptions.CallArrayCopy);
}
case "CanOmitFrame": {
return OptionDescriptor.create(
"CanOmitFrame",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"CanOmitFrame",
GraalOptions.CanOmitFrame);
}
case "ConditionalElimination": {
return OptionDescriptor.create(
"ConditionalElimination",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"ConditionalElimination",
GraalOptions.ConditionalElimination);
}
case "DeoptALot": {
return OptionDescriptor.create(
"DeoptALot",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"DeoptALot",
GraalOptions.DeoptALot);
}
case "DeoptsToDisableOptimisticOptimization": {
return OptionDescriptor.create(
"DeoptsToDisableOptimisticOptimization",
OptionType.Expert,
Integer.class,
"",
GraalOptions.class,
"DeoptsToDisableOptimisticOptimization",
GraalOptions.DeoptsToDisableOptimisticOptimization);
}
case "EagerSnippets": {
return OptionDescriptor.create(
"EagerSnippets",
OptionType.Debug,
Boolean.class,
"Eagerly construct extra snippet info.",
GraalOptions.class,
"EagerSnippets",
GraalOptions.EagerSnippets);
}
case "EscapeAnalysisIterations": {
return OptionDescriptor.create(
"EscapeAnalysisIterations",
OptionType.Debug,
Integer.class,
"",
GraalOptions.class,
"EscapeAnalysisIterations",
GraalOptions.EscapeAnalysisIterations);
}
case "EscapeAnalysisLoopCutoff": {
return OptionDescriptor.create(
"EscapeAnalysisLoopCutoff",
OptionType.Debug,
Integer.class,
"",
GraalOptions.class,
"EscapeAnalysisLoopCutoff",
GraalOptions.EscapeAnalysisLoopCutoff);
}
case "EscapeAnalyzeOnly": {
return OptionDescriptor.create(
"EscapeAnalyzeOnly",
OptionType.Debug,
String.class,
"",
GraalOptions.class,
"EscapeAnalyzeOnly",
GraalOptions.EscapeAnalyzeOnly);
}
case "FullUnroll": {
return OptionDescriptor.create(
"FullUnroll",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"FullUnroll",
GraalOptions.FullUnroll);
}
case "GCDebugStartCycle": {
return OptionDescriptor.create(
"GCDebugStartCycle",
OptionType.Debug,
Integer.class,
"",
GraalOptions.class,
"GCDebugStartCycle",
GraalOptions.GCDebugStartCycle);
}
case "GenLoopSafepoints": {
return OptionDescriptor.create(
"GenLoopSafepoints",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"GenLoopSafepoints",
GraalOptions.GenLoopSafepoints);
}
case "GenSafepoints": {
return OptionDescriptor.create(
"GenSafepoints",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"GenSafepoints",
GraalOptions.GenSafepoints);
}
case "GeneratePIC": {
return OptionDescriptor.create(
"GeneratePIC",
OptionType.Expert,
Boolean.class,
"Generate position independent code",
GraalOptions.class,
"GeneratePIC",
GraalOptions.GeneratePIC);
}
case "GuardPriorities": {
return OptionDescriptor.create(
"GuardPriorities",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"GuardPriorities",
GraalOptions.GuardPriorities);
}
case "HotSpotPrintInlining": {
return OptionDescriptor.create(
"HotSpotPrintInlining",
OptionType.Debug,
Boolean.class,
"Print inlining optimizations",
GraalOptions.class,
"HotSpotPrintInlining",
GraalOptions.HotSpotPrintInlining);
}
case "ImmutableCode": {
return OptionDescriptor.create(
"ImmutableCode",
OptionType.Expert,
Boolean.class,
"Try to avoid emitting code where patching is required",
GraalOptions.class,
"ImmutableCode",
GraalOptions.ImmutableCode);
}
case "InlineEverything": {
return OptionDescriptor.create(
"InlineEverything",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"InlineEverything",
GraalOptions.InlineEverything);
}
case "InlineMegamorphicCalls": {
return OptionDescriptor.create(
"InlineMegamorphicCalls",
OptionType.Expert,
Boolean.class,
"Inline calls with megamorphic type profile (i.e., not all types could be recorded).",
GraalOptions.class,
"InlineMegamorphicCalls",
GraalOptions.InlineMegamorphicCalls);
}
case "InlineMonomorphicCalls": {
return OptionDescriptor.create(
"InlineMonomorphicCalls",
OptionType.Expert,
Boolean.class,
"Inline calls with monomorphic type profile.",
GraalOptions.class,
"InlineMonomorphicCalls",
GraalOptions.InlineMonomorphicCalls);
}
case "InlinePolymorphicCalls": {
return OptionDescriptor.create(
"InlinePolymorphicCalls",
OptionType.Expert,
Boolean.class,
"Inline calls with polymorphic type profile.",
GraalOptions.class,
"InlinePolymorphicCalls",
GraalOptions.InlinePolymorphicCalls);
}
case "InlineVTableStubs": {
return OptionDescriptor.create(
"InlineVTableStubs",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"InlineVTableStubs",
GraalOptions.InlineVTableStubs);
}
case "Intrinsify": {
return OptionDescriptor.create(
"Intrinsify",
OptionType.Debug,
Boolean.class,
"Use compiler intrinsifications.",
GraalOptions.class,
"Intrinsify",
GraalOptions.Intrinsify);
}
case "LimitInlinedInvokes": {
return OptionDescriptor.create(
"LimitInlinedInvokes",
OptionType.Expert,
Double.class,
"",
GraalOptions.class,
"LimitInlinedInvokes",
GraalOptions.LimitInlinedInvokes);
}
case "LoopMaxUnswitch": {
return OptionDescriptor.create(
"LoopMaxUnswitch",
OptionType.Expert,
Integer.class,
"",
GraalOptions.class,
"LoopMaxUnswitch",
GraalOptions.LoopMaxUnswitch);
}
case "LoopPeeling": {
return OptionDescriptor.create(
"LoopPeeling",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"LoopPeeling",
GraalOptions.LoopPeeling);
}
case "LoopUnswitch": {
return OptionDescriptor.create(
"LoopUnswitch",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"LoopUnswitch",
GraalOptions.LoopUnswitch);
}
case "MatchExpressions": {
return OptionDescriptor.create(
"MatchExpressions",
OptionType.Debug,
Boolean.class,
"Allow backend to match complex expressions.",
GraalOptions.class,
"MatchExpressions",
GraalOptions.MatchExpressions);
}
case "MaximumDesiredSize": {
return OptionDescriptor.create(
"MaximumDesiredSize",
OptionType.User,
Integer.class,
"Maximum desired size of the compiler graph in nodes.",
GraalOptions.class,
"MaximumDesiredSize",
GraalOptions.MaximumDesiredSize);
}
case "MaximumEscapeAnalysisArrayLength": {
return OptionDescriptor.create(
"MaximumEscapeAnalysisArrayLength",
OptionType.Expert,
Integer.class,
"",
GraalOptions.class,
"MaximumEscapeAnalysisArrayLength",
GraalOptions.MaximumEscapeAnalysisArrayLength);
}
case "MaximumInliningSize": {
return OptionDescriptor.create(
"MaximumInliningSize",
OptionType.Expert,
Integer.class,
"Inlining is explored up to this number of nodes in the graph for each call site.",
GraalOptions.class,
"MaximumInliningSize",
GraalOptions.MaximumInliningSize);
}
case "MaximumRecursiveInlining": {
return OptionDescriptor.create(
"MaximumRecursiveInlining",
OptionType.Expert,
Integer.class,
"Maximum level of recursive inlining.",
GraalOptions.class,
"MaximumRecursiveInlining",
GraalOptions.MaximumRecursiveInlining);
}
case "MegamorphicInliningMinMethodProbability": {
return OptionDescriptor.create(
"MegamorphicInliningMinMethodProbability",
OptionType.Expert,
Double.class,
"Minimum probability for methods to be inlined for megamorphic type profiles.",
GraalOptions.class,
"MegamorphicInliningMinMethodProbability",
GraalOptions.MegamorphicInliningMinMethodProbability);
}
case "MinimumPeelProbability": {
return OptionDescriptor.create(
"MinimumPeelProbability",
OptionType.Expert,
Float.class,
"",
GraalOptions.class,
"MinimumPeelProbability",
GraalOptions.MinimumPeelProbability);
}
case "OmitHotExceptionStacktrace": {
return OptionDescriptor.create(
"OmitHotExceptionStacktrace",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OmitHotExceptionStacktrace",
GraalOptions.OmitHotExceptionStacktrace);
}
case "OptAssumptions": {
return OptionDescriptor.create(
"OptAssumptions",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"OptAssumptions",
GraalOptions.OptAssumptions);
}
case "OptClearNonLiveLocals": {
return OptionDescriptor.create(
"OptClearNonLiveLocals",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptClearNonLiveLocals",
GraalOptions.OptClearNonLiveLocals);
}
case "OptConvertDeoptsToGuards": {
return OptionDescriptor.create(
"OptConvertDeoptsToGuards",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptConvertDeoptsToGuards",
GraalOptions.OptConvertDeoptsToGuards);
}
case "OptDeoptimizationGrouping": {
return OptionDescriptor.create(
"OptDeoptimizationGrouping",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptDeoptimizationGrouping",
GraalOptions.OptDeoptimizationGrouping);
}
case "OptDevirtualizeInvokesOptimistically": {
return OptionDescriptor.create(
"OptDevirtualizeInvokesOptimistically",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptDevirtualizeInvokesOptimistically",
GraalOptions.OptDevirtualizeInvokesOptimistically);
}
case "OptEliminateGuards": {
return OptionDescriptor.create(
"OptEliminateGuards",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptEliminateGuards",
GraalOptions.OptEliminateGuards);
}
case "OptEliminatePartiallyRedundantGuards": {
return OptionDescriptor.create(
"OptEliminatePartiallyRedundantGuards",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptEliminatePartiallyRedundantGuards",
GraalOptions.OptEliminatePartiallyRedundantGuards);
}
case "OptFilterProfiledTypes": {
return OptionDescriptor.create(
"OptFilterProfiledTypes",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptFilterProfiledTypes",
GraalOptions.OptFilterProfiledTypes);
}
case "OptFloatingReads": {
return OptionDescriptor.create(
"OptFloatingReads",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptFloatingReads",
GraalOptions.OptFloatingReads);
}
case "OptImplicitNullChecks": {
return OptionDescriptor.create(
"OptImplicitNullChecks",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptImplicitNullChecks",
GraalOptions.OptImplicitNullChecks);
}
case "OptLoopTransform": {
return OptionDescriptor.create(
"OptLoopTransform",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptLoopTransform",
GraalOptions.OptLoopTransform);
}
case "OptReadElimination": {
return OptionDescriptor.create(
"OptReadElimination",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptReadElimination",
GraalOptions.OptReadElimination);
}
case "OptScheduleOutOfLoops": {
return OptionDescriptor.create(
"OptScheduleOutOfLoops",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"OptScheduleOutOfLoops",
GraalOptions.OptScheduleOutOfLoops);
}
case "PEAInliningHints": {
return OptionDescriptor.create(
"PEAInliningHints",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"PEAInliningHints",
GraalOptions.PEAInliningHints);
}
case "PartialEscapeAnalysis": {
return OptionDescriptor.create(
"PartialEscapeAnalysis",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"PartialEscapeAnalysis",
GraalOptions.PartialEscapeAnalysis);
}
case "PartialUnroll": {
return OptionDescriptor.create(
"PartialUnroll",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"PartialUnroll",
GraalOptions.PartialUnroll);
}
case "PrintProfilingInformation": {
return OptionDescriptor.create(
"PrintProfilingInformation",
OptionType.Debug,
Boolean.class,
"Print profiling information when parsing a method's bytecode",
GraalOptions.class,
"PrintProfilingInformation",
GraalOptions.PrintProfilingInformation);
}
case "RawConditionalElimination": {
return OptionDescriptor.create(
"RawConditionalElimination",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"RawConditionalElimination",
GraalOptions.RawConditionalElimination);
}
case "ReadEliminationMaxLoopVisits": {
return OptionDescriptor.create(
"ReadEliminationMaxLoopVisits",
OptionType.Debug,
Integer.class,
"",
GraalOptions.class,
"ReadEliminationMaxLoopVisits",
GraalOptions.ReadEliminationMaxLoopVisits);
}
case "ReassociateInvariants": {
return OptionDescriptor.create(
"ReassociateInvariants",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"ReassociateInvariants",
GraalOptions.ReassociateInvariants);
}
case "RegisterPressure": {
return OptionDescriptor.create(
"RegisterPressure",
OptionType.Debug,
String.class,
"Comma separated list of registers that register allocation is limited to.",
GraalOptions.class,
"RegisterPressure",
GraalOptions.RegisterPressure);
}
case "RemoveNeverExecutedCode": {
return OptionDescriptor.create(
"RemoveNeverExecutedCode",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"RemoveNeverExecutedCode",
GraalOptions.RemoveNeverExecutedCode);
}
case "ReplaceInputsWithConstantsBasedOnStamps": {
return OptionDescriptor.create(
"ReplaceInputsWithConstantsBasedOnStamps",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"ReplaceInputsWithConstantsBasedOnStamps",
GraalOptions.ReplaceInputsWithConstantsBasedOnStamps);
}
case "ResolveClassBeforeStaticInvoke": {
return OptionDescriptor.create(
"ResolveClassBeforeStaticInvoke",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"ResolveClassBeforeStaticInvoke",
GraalOptions.ResolveClassBeforeStaticInvoke);
}
case "SmallCompiledLowLevelGraphSize": {
return OptionDescriptor.create(
"SmallCompiledLowLevelGraphSize",
OptionType.Expert,
Integer.class,
"If the previous low-level graph size of the method exceeds the threshold, it is not inlined.",
GraalOptions.class,
"SmallCompiledLowLevelGraphSize",
GraalOptions.SmallCompiledLowLevelGraphSize);
}
case "SnippetCounters": {
return OptionDescriptor.create(
"SnippetCounters",
OptionType.Debug,
Boolean.class,
"Enable counters for various paths in snippets.",
GraalOptions.class,
"SnippetCounters",
GraalOptions.SnippetCounters);
}
case "StressExplicitExceptionCode": {
return OptionDescriptor.create(
"StressExplicitExceptionCode",
OptionType.Debug,
Boolean.class,
"Stress the code emitting explicit exception throwing code.",
GraalOptions.class,
"StressExplicitExceptionCode",
GraalOptions.StressExplicitExceptionCode);
}
case "StressInvokeWithExceptionNode": {
return OptionDescriptor.create(
"StressInvokeWithExceptionNode",
OptionType.Debug,
Boolean.class,
"Stress the code emitting invokes with explicit exception edges.",
GraalOptions.class,
"StressInvokeWithExceptionNode",
GraalOptions.StressInvokeWithExceptionNode);
}
case "StressTestEarlyReads": {
return OptionDescriptor.create(
"StressTestEarlyReads",
OptionType.Debug,
Boolean.class,
"Stress the code by emitting reads at earliest instead of latest point.",
GraalOptions.class,
"StressTestEarlyReads",
GraalOptions.StressTestEarlyReads);
}
case "SupportJsrBytecodes": {
return OptionDescriptor.create(
"SupportJsrBytecodes",
OptionType.Expert,
Boolean.class,
"",
GraalOptions.class,
"SupportJsrBytecodes",
GraalOptions.SupportJsrBytecodes);
}
case "TailDuplicationProbability": {
return OptionDescriptor.create(
"TailDuplicationProbability",
OptionType.Expert,
Double.class,
"",
GraalOptions.class,
"TailDuplicationProbability",
GraalOptions.TailDuplicationProbability);
}
case "TailDuplicationTrivialSize": {
return OptionDescriptor.create(
"TailDuplicationTrivialSize",
OptionType.Expert,
Integer.class,
"",
GraalOptions.class,
"TailDuplicationTrivialSize",
GraalOptions.TailDuplicationTrivialSize);
}
case "TraceEscapeAnalysis": {
return OptionDescriptor.create(
"TraceEscapeAnalysis",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"TraceEscapeAnalysis",
GraalOptions.TraceEscapeAnalysis);
}
case "TraceInlining": {
return OptionDescriptor.create(
"TraceInlining",
OptionType.Debug,
Boolean.class,
"Enable tracing of inlining decisions.",
new String[] {
"Output format:",
" compilation of 'Signature of the compilation root method':",
" at 'Signature of the root method' ['Bytecode index']: <'Phase'> 'Child method signature': 'Decision made about this callsite'",
" at 'Signature of the child method' ['Bytecode index']: ",
" |--<'Phase 1'> 'Grandchild method signature': 'First decision made about this callsite'",
" \\--<'Phase 2'> 'Grandchild method signature': 'Second decision made about this callsite'",
" at 'Signature of the child method' ['Bytecode index']: <'Phase'> 'Another grandchild method signature': 'The only decision made about this callsite.'",
},
GraalOptions.class,
"TraceInlining",
GraalOptions.TraceInlining);
}
case "TraceInliningForStubsAndSnippets": {
return OptionDescriptor.create(
"TraceInliningForStubsAndSnippets",
OptionType.Debug,
Boolean.class,
"Enable inlining decision tracing in stubs and snippets.",
GraalOptions.class,
"TraceInliningForStubsAndSnippets",
GraalOptions.TraceInliningForStubsAndSnippets);
}
case "TraceRA": {
return OptionDescriptor.create(
"TraceRA",
OptionType.Debug,
Boolean.class,
"Enable experimental Trace Register Allocation.",
GraalOptions.class,
"TraceRA",
GraalOptions.TraceRA);
}
case "TrackNodeInsertion": {
return OptionDescriptor.create(
"TrackNodeInsertion",
OptionType.Debug,
Boolean.class,
"Track source stack trace where a node was inserted into the graph.",
GraalOptions.class,
"TrackNodeInsertion",
GraalOptions.TrackNodeInsertion);
}
case "TrackNodeSourcePosition": {
return OptionDescriptor.create(
"TrackNodeSourcePosition",
OptionType.Debug,
Boolean.class,
"Track the NodeSourcePosition.",
GraalOptions.class,
"TrackNodeSourcePosition",
GraalOptions.TrackNodeSourcePosition);
}
case "TrivialInliningSize": {
return OptionDescriptor.create(
"TrivialInliningSize",
OptionType.Expert,
Integer.class,
"Graphs with less than this number of nodes are trivial and therefore always inlined.",
GraalOptions.class,
"TrivialInliningSize",
GraalOptions.TrivialInliningSize);
}
case "UseExceptionProbability": {
return OptionDescriptor.create(
"UseExceptionProbability",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"UseExceptionProbability",
GraalOptions.UseExceptionProbability);
}
case "UseLoopLimitChecks": {
return OptionDescriptor.create(
"UseLoopLimitChecks",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"UseLoopLimitChecks",
GraalOptions.UseLoopLimitChecks);
}
case "UseSnippetGraphCache": {
return OptionDescriptor.create(
"UseSnippetGraphCache",
OptionType.Debug,
Boolean.class,
"Use a cache for snippet graphs.",
GraalOptions.class,
"UseSnippetGraphCache",
GraalOptions.UseSnippetGraphCache);
}
case "UseTypeCheckHints": {
return OptionDescriptor.create(
"UseTypeCheckHints",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"UseTypeCheckHints",
GraalOptions.UseTypeCheckHints);
}
case "VerifyHeapAtReturn": {
return OptionDescriptor.create(
"VerifyHeapAtReturn",
OptionType.Debug,
Boolean.class,
"Perform platform dependent validation of the Java heap at returns",
GraalOptions.class,
"VerifyHeapAtReturn",
GraalOptions.VerifyHeapAtReturn);
}
case "VerifyPhases": {
return OptionDescriptor.create(
"VerifyPhases",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"VerifyPhases",
GraalOptions.VerifyPhases);
}
case "ZapStackOnMethodEntry": {
return OptionDescriptor.create(
"ZapStackOnMethodEntry",
OptionType.Debug,
Boolean.class,
"",
GraalOptions.class,
"ZapStackOnMethodEntry",
GraalOptions.ZapStackOnMethodEntry);
}
}
return null;
}
@Override
public Iterator<OptionDescriptor> iterator() {
return new Iterator<OptionDescriptor>() {
int i = 0;
@Override
public boolean hasNext() {
return i < 82;
}
@Override
public OptionDescriptor next() {
switch (i++) {
case 0: return get("AlwaysInlineVTableStubs");
case 1: return get("CallArrayCopy");
case 2: return get("CanOmitFrame");
case 3: return get("ConditionalElimination");
case 4: return get("DeoptALot");
case 5: return get("DeoptsToDisableOptimisticOptimization");
case 6: return get("EagerSnippets");
case 7: return get("EscapeAnalysisIterations");
case 8: return get("EscapeAnalysisLoopCutoff");
case 9: return get("EscapeAnalyzeOnly");
case 10: return get("FullUnroll");
case 11: return get("GCDebugStartCycle");
case 12: return get("GenLoopSafepoints");
case 13: return get("GenSafepoints");
case 14: return get("GeneratePIC");
case 15: return get("GuardPriorities");
case 16: return get("HotSpotPrintInlining");
case 17: return get("ImmutableCode");
case 18: return get("InlineEverything");
case 19: return get("InlineMegamorphicCalls");
case 20: return get("InlineMonomorphicCalls");
case 21: return get("InlinePolymorphicCalls");
case 22: return get("InlineVTableStubs");
case 23: return get("Intrinsify");
case 24: return get("LimitInlinedInvokes");
case 25: return get("LoopMaxUnswitch");
case 26: return get("LoopPeeling");
case 27: return get("LoopUnswitch");
case 28: return get("MatchExpressions");
case 29: return get("MaximumDesiredSize");
case 30: return get("MaximumEscapeAnalysisArrayLength");
case 31: return get("MaximumInliningSize");
case 32: return get("MaximumRecursiveInlining");
case 33: return get("MegamorphicInliningMinMethodProbability");
case 34: return get("MinimumPeelProbability");
case 35: return get("OmitHotExceptionStacktrace");
case 36: return get("OptAssumptions");
case 37: return get("OptClearNonLiveLocals");
case 38: return get("OptConvertDeoptsToGuards");
case 39: return get("OptDeoptimizationGrouping");
case 40: return get("OptDevirtualizeInvokesOptimistically");
case 41: return get("OptEliminateGuards");
case 42: return get("OptEliminatePartiallyRedundantGuards");
case 43: return get("OptFilterProfiledTypes");
case 44: return get("OptFloatingReads");
case 45: return get("OptImplicitNullChecks");
case 46: return get("OptLoopTransform");
case 47: return get("OptReadElimination");
case 48: return get("OptScheduleOutOfLoops");
case 49: return get("PEAInliningHints");
case 50: return get("PartialEscapeAnalysis");
case 51: return get("PartialUnroll");
case 52: return get("PrintProfilingInformation");
case 53: return get("RawConditionalElimination");
case 54: return get("ReadEliminationMaxLoopVisits");
case 55: return get("ReassociateInvariants");
case 56: return get("RegisterPressure");
case 57: return get("RemoveNeverExecutedCode");
case 58: return get("ReplaceInputsWithConstantsBasedOnStamps");
case 59: return get("ResolveClassBeforeStaticInvoke");
case 60: return get("SmallCompiledLowLevelGraphSize");
case 61: return get("SnippetCounters");
case 62: return get("StressExplicitExceptionCode");
case 63: return get("StressInvokeWithExceptionNode");
case 64: return get("StressTestEarlyReads");
case 65: return get("SupportJsrBytecodes");
case 66: return get("TailDuplicationProbability");
case 67: return get("TailDuplicationTrivialSize");
case 68: return get("TraceEscapeAnalysis");
case 69: return get("TraceInlining");
case 70: return get("TraceInliningForStubsAndSnippets");
case 71: return get("TraceRA");
case 72: return get("TrackNodeInsertion");
case 73: return get("TrackNodeSourcePosition");
case 74: return get("TrivialInliningSize");
case 75: return get("UseExceptionProbability");
case 76: return get("UseLoopLimitChecks");
case 77: return get("UseSnippetGraphCache");
case 78: return get("UseTypeCheckHints");
case 79: return get("VerifyHeapAtReturn");
case 80: return get("VerifyPhases");
case 81: return get("ZapStackOnMethodEntry");
}
throw new NoSuchElementException();
}
};
}
}