Implement HostCompilerDirectives.InliningRoot and increase exploration budget and maximum subtree invokes for the host inlining heuristic.

chumer · chumer · commit f135f28c45e3 · 2025-09-08T16:38:18.000+02:00
diff --git a/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironment.java b/compiler/src/jdk.graal.compiler.libgraal/src/jdk/graal/compiler/libgraal/truffle/LibGraalTruffleHostEnvironment.java
@@ -106,6 +106,7 @@ protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
             boolean isBytecodeInterpreterSwitch = false;
             boolean isBytecodeInterpreterSwitchBoundary = false;
             boolean isInliningCutoff = false;
+            boolean isInliningRoot = false;
             for (AnnotationData annotationData : annotationDataList) {
                 String annotationTypeFqn = annotationData.getAnnotationType().getName();
                 if (hostTypes.TruffleBoundary.getName().equals(annotationTypeFqn)) {
@@ -116,9 +117,11 @@ protected HostMethodInfo computeValue(ResolvedJavaMethod method) {
                     isBytecodeInterpreterSwitchBoundary = true;
                 } else if (hostTypes.InliningCutoff.getName().equals(annotationTypeFqn)) {
                     isInliningCutoff = true;
+                } else if (hostTypes.InliningRoot != null && hostTypes.InliningRoot.getName().equals(annotationTypeFqn)) {
+                    isInliningRoot = true;
                 }
             }
-            return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff);
+            return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, isInliningRoot);
         }
 
     }
diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/HostInliningTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/HostInliningTest.java
@@ -49,6 +49,7 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.HostCompilerDirectives.BytecodeInterpreterSwitch;
 import com.oracle.truffle.api.HostCompilerDirectives.InliningCutoff;
+import com.oracle.truffle.api.HostCompilerDirectives.InliningRoot;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.ImplicitCast;
@@ -150,13 +151,14 @@ public void test() {
         runTest("testImplicitCast");
         runTest("testNativeCall");
         runTest("testBCDSLPrologIfVersion");
+        runTest("testInliningRoot");
     }
 
     /*
      * Test for GR-69170
      */
     @BytecodeInterpreterSwitch
-    static Object testBCDSLPrologIfVersion(int value) {
+    static Object testBCDSLPrologIfVersion(@SuppressWarnings("unused") int value) {
         Object o = null;
         if (!CompilerDirectives.inInterpreter() && CompilerDirectives.hasNextTier()) {
             GraalDirectives.deoptimize();
@@ -1002,6 +1004,13 @@ static int testIndirectIntrinsicsImpl(A a) {
         return a.intrinsic(); // inlined and intrinsic
     }
 
+    @InliningRoot
+    static int testInliningRoot(int value) {
+        // should work just like bytecode interpreter switches
+        trivialMethod();
+        return value;
+    }
+
     @Retention(RetentionPolicy.RUNTIME)
     @Target(ElementType.METHOD)
     @interface ExpectSameGraph {
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/host/HostInliningPhase.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/host/HostInliningPhase.java
@@ -106,6 +106,9 @@ public static class Options {
         @Option(help = "Maximum budget for Truffle host inlining for runtime compiled methods.")//
         public static final OptionKey<Integer> TruffleHostInliningBaseBudget = new OptionKey<>(5_000);
 
+        @Option(help = "Maximum exploration budget for Truffle host inlining when exploring inlining candidates.")//
+        public static final OptionKey<Integer> TruffleHostInliningExploreBudget = new OptionKey<>(10_000);
+
         @Option(help = "Maximum budget for Truffle host inlining for runtime compiled methods with a BytecodeInterpreterSwitch annotation.")//
         public static final OptionKey<Integer> TruffleHostInliningByteCodeInterpreterBudget = new OptionKey<>(100_000);
 
@@ -116,7 +119,7 @@ public static class Options {
         public static final OptionKey<Integer> TruffleHostInliningMaxExplorationDepth = new OptionKey<>(1000);
 
         @Option(help = "Maximum number of subtree invokes for a subtree to get inlined until it is considered too complex.")//
-        public static final OptionKey<Integer> TruffleHostInliningMaxSubtreeInvokes = new OptionKey<>(20);
+        public static final OptionKey<Integer> TruffleHostInliningMaxSubtreeInvokes = new OptionKey<>(32);
 
         @Option(help = "Minimum relative frequency for calls to get inlined. Default 0.001 on HotSpot and no minimum frequency on SVM.")//
         public static final OptionKey<Double> TruffleHostInliningMinFrequency = new OptionKey<>(DEFAULT_MIN_FREQUENCY);
@@ -144,7 +147,7 @@ public HostInliningPhase(CanonicalizerPhase canonicalizer, double defaultMinProf
     }
 
     protected boolean isEnabledFor(TruffleHostEnvironment env, ResolvedJavaMethod method) {
-        return isBytecodeInterpreterSwitch(env, method);
+        return isBytecodeInterpreterSwitch(env, method) || isInliningRoot(env, method);
     }
 
     protected String isTruffleBoundary(TruffleHostEnvironment env, ResolvedJavaMethod targetMethod) {
@@ -154,14 +157,18 @@ protected String isTruffleBoundary(TruffleHostEnvironment env, ResolvedJavaMetho
         return null;
     }
 
-    private boolean isBytecodeInterpreterSwitch(TruffleHostEnvironment env, ResolvedJavaMethod targetMethod) {
+    protected final boolean isBytecodeInterpreterSwitch(TruffleHostEnvironment env, ResolvedJavaMethod targetMethod) {
         return env.getHostMethodInfo(translateMethod(targetMethod)).isBytecodeInterpreterSwitch();
     }
 
     private boolean isInliningCutoff(TruffleHostEnvironment env, ResolvedJavaMethod targetMethod) {
         return env.getHostMethodInfo(translateMethod(targetMethod)).isInliningCutoff();
     }
 
+    private boolean isInliningRoot(TruffleHostEnvironment env, ResolvedJavaMethod targetMethod) {
+        return env.getHostMethodInfo(translateMethod(targetMethod)).isInliningRoot();
+    }
+
     protected ResolvedJavaMethod translateMethod(ResolvedJavaMethod method) {
         return method;
     }
@@ -213,11 +220,10 @@ private void runImpl(InliningPhaseContext context) {
              * all together and fail if the graph becomes too big.
              */
             sizeLimit = Options.TruffleHostInliningByteCodeInterpreterBudget.getValue(context.graph.getOptions());
-            exploreLimit = Options.TruffleHostInliningBaseBudget.getValue(context.graph.getOptions());
         } else {
             sizeLimit = Options.TruffleHostInliningBaseBudget.getValue(context.graph.getOptions());
-            exploreLimit = sizeLimit;
         }
+        exploreLimit = Options.TruffleHostInliningExploreBudget.getValue(context.graph.getOptions());
 
         if (sizeLimit < 0) {
             /*
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/host/TruffleKnownHostTypes.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/host/TruffleKnownHostTypes.java
@@ -54,6 +54,7 @@ public final class TruffleKnownHostTypes extends AbstractKnownTruffleTypes {
     public final ResolvedJavaType BytecodeInterpreterSwitch = lookupType("com.oracle.truffle.api.HostCompilerDirectives$BytecodeInterpreterSwitch");
     public final ResolvedJavaType BytecodeInterpreterSwitchBoundary = lookupType("com.oracle.truffle.api.HostCompilerDirectives$BytecodeInterpreterSwitchBoundary");
     public final ResolvedJavaType InliningCutoff = lookupType("com.oracle.truffle.api.HostCompilerDirectives$InliningCutoff");
+    public final ResolvedJavaType InliningRoot = lookupTypeOptional("com.oracle.truffle.api.HostCompilerDirectives$InliningRoot");
 
     public final ResolvedJavaType HostCompilerDirectives = lookupTypeCached("com.oracle.truffle.api.HostCompilerDirectives");
     public final ResolvedJavaMethod HostCompilerDirectives_inInterpreterFastPath = findMethod(HostCompilerDirectives, "inInterpreterFastPath");
diff --git a/truffle/CHANGELOG.md b/truffle/CHANGELOG.md
@@ -11,6 +11,7 @@ This changelog summarizes major changes between Truffle versions relevant to lan
 * GR-67702: Specialization DSL: For nodes annotated with `@GenerateInline`, inlining warnings emitted for `@Cached` expressions are now suppressed if the inlined node is explicitly annotated with `@GenerateInline(false)`. This avoids unnecessary warnings if inlining for a node was explicitly disabled.
 * GR-66310: Added support for passing arrays of primitive types to native code through the Truffle NFI Panama backend.
 * GR-61292 Specialization DSL: Single specialization nodes no longer specialize on first execution unless they use assumptions, cached state, or multiple instances. This was done to improve the interpreter performance and memory footprint of such nodes. As a result, these nodes no longer invalidate on first execution, which means they can no longer be used as an implicit branch profile. Language implementations are encouraged to check whether they are relying on this behavior and insert explicit branch profiles instead (see `BranchProfile` or `InlinedBranchProfile`).
+* GR-69188: Added `@HostCompilerDirectives.InliningRoot` to explicitly trigger host inlining for a method designed for partial evaluation. Note that on SubstrateVM, host inlining is automatically enabled for all runtime-compilable methods, while on HotSpot you must add either `@HostCompilerDirectives.InliningRoot` or `@HostCompilerDirectives.BytecodeInterpreterSwitch` to enable it. Host inlining is only enabled if Graal is enabled as a Java host compiler. 
 
 ## Version 25.0
 * GR-31495 Added ability to specify language and instrument specific options using `Source.Builder.option(String, String)`. Languages may describe available source options by implementing `TruffleLanguage.getSourceOptionDescriptors()` and `TruffleInstrument.getSourceOptionDescriptors()` respectively.
diff --git a/truffle/src/com.oracle.truffle.api/snapshot.sigtest b/truffle/src/com.oracle.truffle.api/snapshot.sigtest
@@ -139,6 +139,7 @@ CLSS public final com.oracle.truffle.api.HostCompilerDirectives
 innr public abstract interface static !annotation BytecodeInterpreterSwitch
 innr public abstract interface static !annotation BytecodeInterpreterSwitchBoundary
 innr public abstract interface static !annotation InliningCutoff
+innr public abstract interface static !annotation InliningRoot
 meth public static boolean inInterpreterFastPath()
 supr java.lang.Object
 
@@ -161,6 +162,12 @@ CLSS public abstract interface static !annotation com.oracle.truffle.api.HostCom
  anno 0 java.lang.annotation.Target(java.lang.annotation.ElementType[] value=[METHOD, CONSTRUCTOR])
 intf java.lang.annotation.Annotation
 
+CLSS public abstract interface static !annotation com.oracle.truffle.api.HostCompilerDirectives$InliningRoot
+ outer com.oracle.truffle.api.HostCompilerDirectives
+ anno 0 java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy value=RUNTIME)
+ anno 0 java.lang.annotation.Target(java.lang.annotation.ElementType[] value=[METHOD, CONSTRUCTOR])
+intf java.lang.annotation.Annotation
+
 CLSS public final com.oracle.truffle.api.InstrumentInfo
 meth public java.lang.String getId()
 meth public java.lang.String getName()
@@ -1762,6 +1769,11 @@ meth public abstract java.lang.annotation.ElementType[] value()
 CLSS public abstract interface java.lang.constant.Constable
 meth public abstract java.util.Optional<? extends java.lang.constant.ConstantDesc> describeConstable()
 
+CLSS public abstract interface !annotation jdk.internal.vm.annotation.AOTSafeClassInitializer
+ anno 0 java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy value=RUNTIME)
+ anno 0 java.lang.annotation.Target(java.lang.annotation.ElementType[] value=[TYPE])
+intf java.lang.annotation.Annotation
+
 CLSS public abstract interface org.graalvm.options.OptionDescriptors
 fld public final static org.graalvm.options.OptionDescriptors EMPTY
 intf java.lang.Iterable<org.graalvm.options.OptionDescriptor>
diff --git a/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/HostCompilerDirectives.java b/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/HostCompilerDirectives.java
@@ -158,4 +158,27 @@ public static boolean inInterpreterFastPath() {
     public @interface InliningCutoff {
     }
 
+    /**
+     * Marks a method as a candidate for Truffle host inlining. The host compiler may use this
+     * information to guide inlining and optimization decisions.
+     * <p>
+     * Annotated methods must be designed for partial evaluation. This annotation should not be
+     * applied to arbitrary Java code or third-party libraries, as doing so may cause severe
+     * performance degradation.
+     * <p>
+     * Typical examples include {@code execute} methods of cached nodes. The Truffle DSL
+     * automatically applies this annotation to every generated execute method. It is recommended to
+     * be used for manually written {@code execute} methods as well.
+     * <p>
+     * For more details, see the
+     * <a href="https://github.com/oracle/graal/blob/master/truffle/docs/HostCompilation.md">
+     * Truffle host compilation documentation</a>.
+     *
+     * @since 26.0
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
+    public @interface InliningRoot {
+    }
+
 }
diff --git a/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/HostMethodInfo.java b/truffle/src/com.oracle.truffle.compiler/src/com/oracle/truffle/compiler/HostMethodInfo.java
@@ -55,6 +55,16 @@ public record HostMethodInfo(
                 boolean isTruffleBoundary,
                 boolean isBytecodeInterpreterSwitch,
                 boolean isBytecodeInterpreterSwitchBoundary,
-                boolean isInliningCutoff) {
+                boolean isInliningCutoff,
+                boolean isInliningRoot) {
+
+    // for compatibility
+    public HostMethodInfo(
+                    boolean isTruffleBoundary,
+                    boolean isBytecodeInterpreterSwitch,
+                    boolean isBytecodeInterpreterSwitchBoundary,
+                    boolean isInliningCutoff) {
+        this(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, false);
+    }
 
 }
diff --git a/truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/TruffleTypes.java b/truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/TruffleTypes.java
@@ -136,6 +136,7 @@ public class TruffleTypes {
     public static final String HostCompilerDirectives_Name = "com.oracle.truffle.api.HostCompilerDirectives";
     public static final String HostCompilerDirectives_BytecodeInterpreterSwitch_Name = "com.oracle.truffle.api.HostCompilerDirectives.BytecodeInterpreterSwitch";
     public static final String HostCompilerDirectives_InliningCutoff_Name = "com.oracle.truffle.api.HostCompilerDirectives.InliningCutoff";
+    public static final String HostCompilerDirectives_InliningRoot_Name = "com.oracle.truffle.api.HostCompilerDirectives.InliningRoot";
 
     public static final String InternalResource_Name = "com.oracle.truffle.api.InternalResource";
     public static final String InternalResource_Id_Name = "com.oracle.truffle.api.InternalResource.Id";
@@ -200,6 +201,7 @@ public class TruffleTypes {
     public final DeclaredType HostCompilerDirectives = c.getDeclaredType(HostCompilerDirectives_Name);
     public final DeclaredType HostCompilerDirectives_BytecodeInterpreterSwitch = c.getDeclaredType(HostCompilerDirectives_BytecodeInterpreterSwitch_Name);
     public final DeclaredType HostCompilerDirectives_InliningCutoff = c.getDeclaredType(HostCompilerDirectives_InliningCutoff_Name);
+    public final DeclaredType HostCompilerDirectives_InliningRoot = c.getDeclaredType(HostCompilerDirectives_InliningRoot_Name);
     public final DeclaredType InternalResource = c.getDeclaredType(InternalResource_Name);
     public final DeclaredType InternalResource_Id = c.getDeclaredType(InternalResource_Id_Name);
     public final DeclaredType InvalidAssumptionException = c.getDeclaredType(InvalidAssumptionException_Name);
diff --git a/truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/FlatNodeGenFactory.java b/truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/FlatNodeGenFactory.java
@@ -2805,6 +2805,7 @@ public CodeExecutableElement createExecuteMethod(CodeTypeElement clazz, CodeExec
 
         List<SpecializationData> implementedSpecializations = allSpecializations;
         CodeExecutableElement method = createExecuteMethod(type);
+        method.addAnnotationMirror(new CodeAnnotationMirror(types.HostCompilerDirectives_InliningRoot));
         FrameState frameState = FrameState.load(this, type, Integer.MAX_VALUE, NodeExecutionMode.FAST_PATH, method);
         if (type.getMethod() == null) {
             frameState.addParametersTo(method, Integer.MAX_VALUE, FRAME_VALUE);
@@ -2830,6 +2831,10 @@ private CodeExecutableElement createExecute(CodeTypeElement clazz, ExecutableTyp
         }
 
         CodeExecutableElement method = createExecuteMethod(type);
+        // exclude inlined nodes they do not make good inlining roots as they rely on being inlined
+        if (!inlined) {
+            method.addAnnotationMirror(new CodeAnnotationMirror(types.HostCompilerDirectives_InliningRoot));
+        }
         FrameState frameState = FrameState.load(this, type, Integer.MAX_VALUE, NodeExecutionMode.FAST_PATH, method);
         frameState.setInlinedNode(inlined);
         if (type.getMethod() == null) {
diff --git a/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/HostToGuestRootNode.java b/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/HostToGuestRootNode.java
@@ -44,6 +44,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.HostCompilerDirectives.InliningRoot;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.nodes.RootNode;
@@ -82,6 +83,7 @@ abstract class HostToGuestRootNode extends RootNode {
     protected abstract Class<?> getReceiverType();
 
     @Override
+    @InliningRoot
     public final Object execute(VirtualFrame frame) {
         Object[] args = frame.getArguments();
         PolyglotLanguageContext languageContext = layer.getSingleConstantLanguageContext(language);
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedTruffleRuntime.java
@@ -91,6 +91,7 @@
 import com.oracle.truffle.api.HostCompilerDirectives;
 import com.oracle.truffle.api.HostCompilerDirectives.BytecodeInterpreterSwitch;
 import com.oracle.truffle.api.HostCompilerDirectives.InliningCutoff;
+import com.oracle.truffle.api.HostCompilerDirectives.InliningRoot;
 import com.oracle.truffle.api.OptimizationFailedException;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
@@ -411,6 +412,7 @@ private static UnmodifiableEconomicMap<String, Class<?>> initLookupTypes(Iterabl
                         HostCompilerDirectives.BytecodeInterpreterSwitch.class,
                         HostCompilerDirectives.BytecodeInterpreterSwitchBoundary.class,
                         HostCompilerDirectives.InliningCutoff.class,
+                        HostCompilerDirectives.InliningRoot.class,
                         InlineDecision.class,
                         CompilerAsserts.class,
                         ExactMath.class,
@@ -537,10 +539,18 @@ protected void installDefaultListeners() {
 
     @Override
     public HostMethodInfo getHostMethodInfo(ResolvedJavaMethod method) {
-        return new HostMethodInfo(isTruffleBoundary(method),
-                        isBytecodeInterpreterSwitch(method),
-                        isBytecodeInterpreterSwitchBoundary(method),
-                        isInliningCutoff(method));
+        if (JAVA_SPECIFICATION_VERSION >= 26) {
+            return new HostMethodInfo(isTruffleBoundary(method),
+                            isBytecodeInterpreterSwitch(method),
+                            isBytecodeInterpreterSwitchBoundary(method),
+                            isInliningCutoff(method),
+                            isInliningRoot(method));
+        } else {
+            return new HostMethodInfo(isTruffleBoundary(method),
+                            isBytecodeInterpreterSwitch(method),
+                            isBytecodeInterpreterSwitchBoundary(method),
+                            isInliningCutoff(method));
+        }
     }
 
     private static boolean isBytecodeInterpreterSwitch(ResolvedJavaMethod method) {
@@ -551,6 +561,10 @@ private static boolean isInliningCutoff(ResolvedJavaMethod method) {
         return getAnnotation(InliningCutoff.class, method) != null;
     }
 
+    private static boolean isInliningRoot(ResolvedJavaMethod method) {
+        return getAnnotation(InliningRoot.class, method) != null;
+    }
+
     @SuppressWarnings("deprecation")
     private static boolean isBytecodeInterpreterSwitchBoundary(ResolvedJavaMethod method) {
         return getAnnotation(com.oracle.truffle.api.HostCompilerDirectives.BytecodeInterpreterSwitchBoundary.class, method) != null;

Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,7 @@ protected HostMethodInfo computeValue(ResolvedJavaMethod method) {`
`106`	`106`	`boolean isBytecodeInterpreterSwitch = false;`
`107`	`107`	`boolean isBytecodeInterpreterSwitchBoundary = false;`
`108`	`108`	`boolean isInliningCutoff = false;`
	`109`	`+ boolean isInliningRoot = false;`
`109`	`110`	`for (AnnotationData annotationData : annotationDataList) {`
`110`	`111`	`String annotationTypeFqn = annotationData.getAnnotationType().getName();`
`111`	`112`	`if (hostTypes.TruffleBoundary.getName().equals(annotationTypeFqn)) {`
`@@ -116,9 +117,11 @@ protected HostMethodInfo computeValue(ResolvedJavaMethod method) {`
`116`	`117`	`isBytecodeInterpreterSwitchBoundary = true;`
`117`	`118`	`} else if (hostTypes.InliningCutoff.getName().equals(annotationTypeFqn)) {`
`118`	`119`	`isInliningCutoff = true;`
	`120`	`+ } else if (hostTypes.InliningRoot != null && hostTypes.InliningRoot.getName().equals(annotationTypeFqn)) {`
	`121`	`+ isInliningRoot = true;`
`119`	`122`	`}`
`120`	`123`	`}`
`121`		`- return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff);`
	`124`	`+ return new HostMethodInfo(isTruffleBoundary, isBytecodeInterpreterSwitch, isBytecodeInterpreterSwitchBoundary, isInliningCutoff, isInliningRoot);`
`122`	`125`	`}`
`123`	`126`
`124`	`127`	`}`