Public API Proposal: Make bool RuntimeHelpers.IsKnownConstant(...) public for all primitive types

[gerhard17]

Background and motivation

Recently two internal IsKnownConstant() overloads in class RuntimeHelpers for char and string? were added.
For a library developer it would be usefull to consume this API like the framework internaly does.

Same performance/codegen reasons apply as with the original (internal) proposal. #11484

At least one overload for each primitive type (+ the existing string) would be wellcomed.

See also: #63734 and #64809

This request has similarities with GNU GCC int __builtin_constant_p (exp)

API Proposal

namespace System.Runtime.CompilerServices
{
    public static partial class RuntimeHelpers
    {
        // The following intrinsics return true if input is a compile-time constant
        // Feel free to add more overloads on demand

       // CHANGE VISIBILITY

        [Intrinsic]
        public static bool IsKnownConstant(string? t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(char t) => false;

        // ADD OVERLOADS

        [Intrinsic]
        public static bool IsKnownConstant(byte t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(sbyte t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(short t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(ushort t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(int t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(uint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(long t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(ulong t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(nint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(nuint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(float t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(double t) => false;

    }
}

API Usage

API can be public used like the current internal usage inside of the runtime.

Alternative Designs

Maybe a true generic Version can be used.

namespace System.Runtime.CompilerServices
{
    public static partial class RuntimeHelpers
    {
        [Intrinsic]
        public static bool IsKnownConstant<T>(T t) => false;
    }
}

Risks

• No breaking change. Not an public API today.

• Will depend on JIT beyond c# language spec.

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[teo-tsirpanis]

I'm in favor of making it generic.

Tagging subscribers to this area: @dotnet/area-system-runtime-compilerservices
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Background and motivation

Recently two internal IsKnownConstant() overloads in class RuntimeHelpers for char and string? were added.
For a library developer it would be usefull to consume this API like the framework internaly does.

Same performance/codegen reasons apply as with the original (internal) proposal. #11484

At least one overload for each primitive type (+ the existing string) would be wellcomed.

See also: #63734 and #64809

This request has similarities with GNU GCC int __builtin_constant_p (exp)

API Proposal

namespace System.Runtime.CompilerServices
{
    public static partial class RuntimeHelpers
    {
        // The following intrinsics return true if input is a compile-time constant
        // Feel free to add more overloads on demand

       // CHANGE VISIBILITY

        [Intrinsic]
        public static bool IsKnownConstant(string? t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(char t) => false;

        // ADD OVERLOADS

        [Intrinsic]
        public static bool IsKnownConstant(byte t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(sbyte t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(short t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(ushort t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(int t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(uint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(long t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(ulong t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(nint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(nuint t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(float t) => false;

        [Intrinsic]
        public static bool IsKnownConstant(double t) => false;

    }
}

API Usage

API can be public used like the current internal usage inside of the runtime.

Alternative Designs

Maybe a true generic Version can be used.

namespace System.Runtime.CompilerServices
{
    public static partial class RuntimeHelpers
    {
        [Intrinsic]
        public static bool IsKnownConstant<T>(T t) => false;
    }
}

Risks

• No breaking change. Not an public API today.

• Will depend on JIT beyond c# language spec.

Author:	gerhard17
Assignees:	-
Labels:	api-suggestion, area-System.Runtime.CompilerServices, untriaged
Milestone:	-

[SupinePandora43]

I'm in favor of making it generic.

Will it be able to consume null reference types and default value types?

[EgorBo]

1. The generic version must be guarded with : unmanaged constraint because with ref types it might introduce a runtime lookup that will prevent inlining
2. Is __builtin_constant popular in the C/C++ world? I've never seen it in the wild. Do you have a real-world scenario where it'd help you?
3. There are unresolved concerns with this API and JIT's inliner, e.g.:

void DoWork(int a)
{
    if (RuntimeHelpers.IsKnownConstant(a) && a == 42)
    {
        // a lot of code
    }
    // a lot of code
}

jit (currently) is not able to give it additional inlining boost only when a == 42 (currently it doesn't boost at all)

[gerhard17]

@EgorBo

• I would be fine with restriction unmanaged.
• I found the C/C++ documentation during internet search. I just searched, if the JIT already implements such a thing. I for myself being somehow familiar with C/C++, I never used it in production code. :-)
• Yes, currently I have such a case in an arbitrary presision floating point library. Common numeric constants given like literals would greatly benefit from this.
• Yes this is similar to my use case. Only a little bit longer switch statement like:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
void DoWork(int a)
{
    if (RuntimeHelpers.IsKnownConstant(a))
    {
        switch(a) {
        case 42:
          // some code
          return;
        case 43:
          // some code
          return;
         // some more cases with some code
       }
    }
    // a lot of generalized, but slower code
}

Btw. thanks for all the cool coding I found by you in this repository!

[gerhard17]

Could restriction unmanaged be dangerous with large structs?
Copying struct data, when no JIT is involved.
Contradicting the performance gain in non JIT environments.

[SupinePandora43]

Could restriction unmanaged be dangerous with large structs? Copying struct data, when no JIT is involved. Contradicting the performance gain in non JIT environments.

What about in and ref readonly?

[jkotas]

unresolved concerns with this API and JIT's inliner

Yep, it would be useful to see this API used in libraries in more places to prove that it actually works except for a few trivial carefully crafted cases.

#64821 was unsuccessfully in using this API for more complex code.

[buyaa-n]

Tag @GrabYourPitchforks for triage as he created the internal API proposal

[gerhard17]

@jkotas
How does the annotation [MethodImpl(MethodImplOptions.AggressiveInlining)] change the inlining behavior?

Will all code be inlined or is only the budget increased to inline more (but maybe not all) code?