Fix for LLVM9 upgrade to limit the unrolling threshold for cases in which we get large numbers of integer operation inside of a loop. When we get into SCEV we can potentially get a stack overflow if the number of instructions gets too large to evaluate.

Change-Id: Iacee3e2ce597ba4edb6d8d1f0bfe2711d8f33539

Author: paigeale

IGC/Compiler/GenTTI.cpp

@@ -222,6 +222,14 @@ namespace llvm {
                     }
                     return Total - PHIs;
                 };
+                auto countIntegerOperations = [](BasicBlock* BB) {
+                    unsigned Int_Instructions = 0;
+                    for (auto BI = BB->begin(), BE = BB->end(); BI != BE; ++BI) {
+                        if (isa<IntegerType>((&*BI)->getType()))
+                            ++Int_Instructions;
+                    }
+                    return Int_Instructions;
+                };
                 auto hasLoad = [](BasicBlock* BB) {
                     for (auto BI = BB->begin(), BE = BB->end(); BI != BE; ++BI)
                         if (isa<LoadInst>(&*BI))
@@ -243,11 +251,13 @@ namespace llvm {
                 };
                 // For innermost loop, allow certain patterns.
                 unsigned Count = 0;
+                unsigned Int_Count = 0;
                 bool HasCall = false;
                 bool HasStore = false;
                 bool MayHasLoadInHeaderOnly = true;
                 for (auto BI = L->block_begin(), BE = L->block_end(); BI != BE; ++BI) {
                     Count += countNonPHI(*BI);
+                    Int_Count += countIntegerOperations(*BI);
                     HasCall |= hasCall(*BI);
                     HasStore |= hasStore(*BI);
                     if (L->getHeader() != *BI)
@@ -263,6 +273,15 @@ namespace llvm {
                     // The following is only available and required from LLVM 3.7+.
                     UP.AllowExpensiveTripCount = true;
                 }
+                //Controls stack size growth being too big to compile. When we get into SCEV
+                //and start processing the i32 instructions we can get too deep in the call stack
+                //that we cause a stack overflow during compilation.
+                unsigned Total_Potential_Inst = TripCount * Int_Count;
+                if (Total_Potential_Inst > 2700)
+                {
+                    UP.Threshold = 2000;
+                    UP.PartialThreshold = 2000;
+                }
             }
             return;
         }