[Android 9.0.3] Enabling LLVM leads to incorrect SkiaSharp drawing behavior in some cases

[janne-hmp]

Description

In my game GnollHack, I have a specialized drawing function called DrawTileWithRadialTransparency that uses SkiaSharp to draw radial transparency for a bitmap. The function works always (on all platforms and in both Xamarin and MAUI), except for MAUI in Android in release mode when EnableLLVM is set to true and AndroidEnableProfileAot set to false, in which case it either does not draw anything or draws something in the wrong place with a wrong size. This seems to be some sort of an LLVM code generation bug, as the behavior makes otherwise little sense (it feels like the program does not do what is instructed in the code). Not sure why the problems occur just with this function, although it is a bit more complicated than the other ones. If I comment some parts of the code out (e.g. the unsafe block) or add something, the function most often still does not work as intended.

Reproduction Steps

1. Clone the reproduction repository at https://github.com/hyvanmielenpelit/GnollHackMAUIEasyBuild
2. Open GnollHackM solution
3. Build it for Android in Release configuration according to instructions in the repository
4. Note that EnableLLVM is on.
5. Start the app on your Android device
6. Press Settings button and switch Developer Mode on in System section, then press Close
7. Switch on Wizard Mode
8. Press Play Game, create a character and start playing
9. Press More Commands button on bottom right corner, and scroll then left to Wizard Mode Commands
10. Select Genesis and type yellow light
11. A yellow light monster appears, but it has no graphics
12. Quit the game and exit app
13. Switch EnableLLVM to off and AndroidEnableProfiledAot to true.
14. Go to step 3. In step 11, note that the yellow light has now graphics.

Expected behavior

Radial transparency function works with Android Release mode with EnableLLVM = true just like in every other case.

Actual behavior

The drawn picture either is not drawn or is drawn in the wrong position with the wrong size.

Regression?

Not sure. This is an LLVM problem.

Known Workarounds

None. Cannot use LLVM if I want to use the function in question.

Configuration

.NET 9.0.3, .NET MAUI 9.0.50, SkiaSharp 3.116.1
Android 15, ARM64

Other information

No response

[janne-hmp]

As an additional remark, if I move the code from the radial transparency function to the function calling it, then the whole parent function malfunctions, even when the radial transparency code is not even executed at all (no tiles with such transparency being drawn), so this indeed seems to be some sort of a code compilation error.

[janne-hmp]

@jonathanpeppers Just to note that I'm having a really weird problem with LLVM on Android: One function seems to have been somehow incorrectly compiled.

[dotnet-policy-service]

Tagging subscribers to this area: @steveisok, @vitek-karas
See info in area-owners.md if you want to be subscribed.

[janne-hmp]

When I refactored the code of the DrawTileWithRadialTransparency function and split it in 4 subfunctions (each just holding part of the original code), things started to function with LLVM enabled (the code generation bug did not occur). The new code is as follows, and can be in its entirety found in the main repository at https://github.com/hyvanmielenpelit/GnollHack . The malfunctioning original code is in the reproduction repository at https://github.com/hyvanmielenpelit/GnollHackMAUIEasyBuild .

public void DrawTileWithRadialTransparency(SKCanvas canvas, bool delayedDraw, SKImage tileSheet, SKRect sourcerect, SKRect targetrect, ref LayerInfo layers, float destSplitY, float opaqueness, SKPaint paint, int mapX, int mapY, float canvaswidth, float canvasheight, float targetscale, bool usingGL, bool usingMipMap, bool fixRects)
        {
            bool cache = false;
            if (sourcerect.Left % GHConstants.TileWidth == 0 && sourcerect.Top % GHConstants.TileHeight == 0
                && sourcerect.Width == GHConstants.TileWidth && sourcerect.Height == GHConstants.TileHeight)
                cache = true;

            if (cache && RetrieveCachedRadialTile(canvas, delayedDraw, tileSheet, sourcerect, targetrect, ref layers, destSplitY, opaqueness, paint, mapX, mapY, canvaswidth, canvasheight, targetscale, usingGL, usingMipMap, fixRects))
                return;

            int copywidth, copyheight;
            if (!ProcessRadialTile(canvas, delayedDraw, tileSheet, sourcerect, targetrect, ref layers, destSplitY, opaqueness, paint, mapX, mapY, canvaswidth, canvasheight, targetscale, usingGL, usingMipMap, fixRects, out copywidth, out copyheight))
                return;

            SetRadialTileExtraTransparency(ref layers, paint, opaqueness);

            SKRect tempsourcerect = new SKRect(0, 0, copywidth, copyheight);
            if (cache)
                CacheRadialTileAndDraw(canvas, delayedDraw, tileSheet, sourcerect, targetrect, ref layers, destSplitY, opaqueness, paint, mapX, mapY, canvaswidth, canvasheight, targetscale, usingGL, usingMipMap, fixRects, tempsourcerect);
            else
                DrawSplitBitmap(canvas, delayedDraw, destSplitY, SKImage.FromBitmap(_tempBitmap), tempsourcerect, targetrect, paint, mapX, mapY, canvaswidth, canvasheight, targetscale, usingGL, usingMipMap, fixRects);
        }

Not sure what it exactly is, since things did not seem to work even when I commented the unsafe block out in the original code, but did work when I commented the cache code out, but that code is much simpler, so hard to understand why it would be any problem for LLVM. All of this points out to some sort of a code generation bug with LLVM (potentially with the cache code somehow).