Bug fixes from dead code elimination

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/coreclr/jit/fgopt.cpp

@@ -654,6 +654,7 @@ bool Compiler::fgRemoveDeadBlocks()
  JITDUMP("\n*************** In fgRemoveDeadBlocks()");
 
  jitstd::list<BasicBlock*> worklist(jitstd::allocator<void>(getAllocator(CMK_Reachability)));
+
  worklist.push_back(fgFirstBB);
 
  // Do not remove handler blocks
@@ -713,16 +714,43 @@ bool Compiler::fgRemoveDeadBlocks()
  }
  }
 
+ // Track if there is any unreachable block. Even if it is marked with
+ // BBF_DONT_REMOVE, fgRemoveUnreachableBlocks() still removes the code
+ // inside the block. So this variable tracks if we ever found such blocks
+ // or not.
+ bool hasUnreachableBlock = false;
+
  // A block is unreachable if no path was found from
  // any of the fgFirstBB, handler, filter or BBJ_ALWAYS (Arm) blocks.
  auto isBlockRemovable = [&](BasicBlock* block) -> bool {
- return !BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isVisited = BlockSetOps::IsMember(this, visitedBlocks, block->bbNum);
+ bool isRemovable = (!isVisited || block->bbRefs == 0);
+
+#if defined(FEATURE_EH_FUNCLETS) && defined(TARGET_ARM)
+ isRemovable &=
+ !block->isBBCallAlwaysPairTail(); // can't remove the BBJ_ALWAYS of a BBJ_CALLFINALLY / BBJ_ALWAYS pair
+#endif
+ hasUnreachableBlock |= isRemovable;
+
+ return isRemovable;
  };
 
- bool changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ bool changed = false;
+ unsigned iterationCount = 1;
+ do
+ {
+ JITDUMP("\nRemoving unreachable blocks for fgRemoveDeadBlocks iteration #%u\n", iterationCount);
+
+ // Just to be paranoid, avoid infinite loops; fall back to minopts.
+ if (iterationCount++ > 10)
+ {
+ noway_assert(!"Too many unreachable block removal loops");
+ }
+ changed = fgRemoveUnreachableBlocks(isBlockRemovable);
+ } while (changed);
 
 #ifdef DEBUG
- if (verbose && changed)
+ if (verbose && hasUnreachableBlock)
  {
  printf("\nAfter dead block removal:\n");
  fgDispBasicBlocks(verboseTrees);
@@ -732,7 +760,7 @@ bool Compiler::fgRemoveDeadBlocks()
  fgVerifyHandlerTab();
  fgDebugCheckBBlist(false);
 #endif // DEBUG
- return changed;
+ return hasUnreachableBlock;
 }
 
 //-------------------------------------------------------------

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, although we were not removing an unreachable block, we were removing all the code
+// inside it and as such should update the liveness information. Since we were not updating the liveness
+// information for such scenarios, we were hitting an assert during register allocation.
+public class Program
+{
+ public static ulong[] s_14;
+ public static uint s_34;
+ public static int Main()
+ {
+ var vr2 = new ulong[][]{new ulong[]{0}};
+ M27(s_34, vr2);
+ return 100;
+ }
+
+ public static void M27(uint arg4, ulong[][] arg5)
+ {
+ arg5[0][0] = arg5[0][0];
+ for (int var7 = 0; var7 < 1; var7++)
+ {
+ return;
+ }
+
+ try
+ {
+ s_14 = arg5[0];
+ }
+ finally
+ {
+ arg4 = arg4;
+ }
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_1.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// In this issue, we were not removing all the unreachable blocks and that led us to expect that
+// there should be an IG label for one of the unreachable block, but we were not creating it leading
+// to an assert failure.
+public class _65659_2
+{
+ public static bool[][,] s_2;
+ public static short[,][] s_8;
+ public static bool[] s_10;
+ public static ushort[][] s_29;
+ public static int Main()
+ {
+ bool vr1 = M47();
+ return 100;
+ }
+
+ public static bool M47()
+ {
+ bool var0 = default(bool);
+ try
+ {
+ if (var0)
+ {
+ try
+ {
+ if (s_10[0])
+ {
+ return s_2[0][0, 0];
+ }
+ }
+ finally
+ {
+ s_8[0, 0][0] = 0;
+ }
+ }
+ }
+ finally
+ {
+ s_29 = s_29;
+ }
+
+ return true;
+ }
+}

src/tests/JIT/Regression/JitBlue/GitHub_69659/GitHub_69659_2.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+	<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ </PropertyGroup>
+ <PropertyGroup>
+ <DebugType>PdbOnly</DebugType>
+ <Optimize>True</Optimize>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="$(MSBuildProjectName).cs" />
+ </ItemGroup>
+</Project>