[WIP] Handle Non-outermost Dynamic Loops

enzyme/Enzyme/GradientUtils.cpp

@@ -164,6 +164,10 @@ static bool isParentOrSameContext(LoopContext & possibleChild, LoopContext & pos
 
             // Case 2: The correct exiting block terminator unconditionally branches a different block, change to a conditional branch depending on if we are the first iteration
             } else if (succ.size() == 1) {
+                lc.latchMerge->getTerminator()->eraseFromParent();
+                mergeBuilder.SetInsertPoint(lc.latchMerge);
+
+                assert(mergeBuilder.GetInsertBlock()->size() == 0 || !isa<BranchInst>(mergeBuilder.GetInsertBlock()->back()));
 
                 // If first iteration, branch to the exiting block, otherwise the backlatch
                 mergeBuilder.CreateCondBr(firstiter, succ[0], reverseBlocks[backlatch]);
@@ -187,6 +191,8 @@ static bool isParentOrSameContext(LoopContext & possibleChild, LoopContext & pos
 
                 lc.latchMerge->getTerminator()->eraseFromParent();
                 mergeBuilder.SetInsertPoint(lc.latchMerge);
+
+                assert(mergeBuilder.GetInsertBlock()->size() == 0 || !isa<BranchInst>(mergeBuilder.GetInsertBlock()->back()));
                 mergeBuilder.CreateCondBr(firstiter, splitBlock, reverseBlocks[backlatch]);
 
             }
@@ -858,6 +864,7 @@ void GradientUtils::branchToCorrespondingTarget(BasicBlock* ctx, IRBuilder <>& B
 
   if (targetToPreds.size() == 1) {
       if (replacePHIs == nullptr) {
+          assert(BuilderM.GetInsertBlock()->size() == 0 || !isa<BranchInst>(BuilderM.GetInsertBlock()->back()));
           BuilderM.CreateBr( targetToPreds.begin()->first );
       } else {
           for (auto pair : *replacePHIs) {
@@ -962,6 +969,7 @@ void GradientUtils::branchToCorrespondingTarget(BasicBlock* ctx, IRBuilder <>& B
       Value* phi = lookupValueFromCache(BuilderM, ctx, cache);
 
       if (replacePHIs == nullptr) {
+          assert(BuilderM.GetInsertBlock()->size() == 0 || !isa<BranchInst>(BuilderM.GetInsertBlock()->back()));
           BuilderM.CreateCondBr(phi, *done[std::make_pair(block, branch->getSuccessor(0))].begin(), *done[std::make_pair(block, branch->getSuccessor(1))].begin());
       } else {
           for (auto pair : *replacePHIs) {
@@ -1076,6 +1084,7 @@ void GradientUtils::branchToCorrespondingTarget(BasicBlock* ctx, IRBuilder <>& B
 
   if (replacePHIs == nullptr) {
       if (targetToPreds.size() == 2) {
+          assert(BuilderM.GetInsertBlock()->size() == 0 || !isa<BranchInst>(BuilderM.GetInsertBlock()->back()));
           BuilderM.CreateCondBr(which, /*true*/targets[1], /*false*/targets[0]);
       } else {
           auto swit = BuilderM.CreateSwitch(which, targets.back(), targets.size()-1);

enzyme/functional_tests_c/setup.sh

@@ -1,8 +1,8 @@
 #!/bin/bash
 
 # NOTE(TFK): Uncomment for local testing.
-export CLANG_BIN_PATH=./../../llvm/build/bin
-export ENZYME_PLUGIN=./../build/Enzyme/LLVMEnzyme-7.so
+export CLANG_BIN_PATH=./../../build-dbg/bin
+export ENZYME_PLUGIN=./../mkdebug/Enzyme/LLVMEnzyme-7.so
 
 mkdir -p build
 $@

enzyme/functional_tests_c/testfiles/insertsort_sum-enzyme0.test

@@ -0,0 +1,6 @@
+; RUN: cd %desired_wd
+; RUN: make clean-insertsort_sum-enzyme0 ENZYME_PLUGIN=%loadEnzyme
+; RUN: make build/insertsort_sum-enzyme0 ENZYME_PLUGIN=%loadEnzyme CLANG_BIN_PATH=%clangBinPath
+; RUN: build/insertsort_sum-enzyme0
+; RUN: make clean-insertsort_sum-enzyme0 ENZYME_PLUGIN=%loadEnzyme
+

enzyme/functional_tests_c/testfiles/insertsort_sum-enzyme1.test

@@ -0,0 +1,6 @@
+; RUN: cd %desired_wd
+; RUN: make clean-insertsort_sum-enzyme1 ENZYME_PLUGIN=%loadEnzyme
+; RUN: make build/insertsort_sum-enzyme1 ENZYME_PLUGIN=%loadEnzyme CLANG_BIN_PATH=%clangBinPath
+; RUN: build/insertsort_sum-enzyme1
+; RUN: make clean-insertsort_sum-enzyme1 ENZYME_PLUGIN=%loadEnzyme
+

enzyme/functional_tests_c/testfiles/insertsort_sum-enzyme2.test

@@ -0,0 +1,6 @@
+; RUN: cd %desired_wd
+; RUN: make clean-insertsort_sum-enzyme2 ENZYME_PLUGIN=%loadEnzyme
+; RUN: make build/insertsort_sum-enzyme2 ENZYME_PLUGIN=%loadEnzyme CLANG_BIN_PATH=%clangBinPath
+; RUN: build/insertsort_sum-enzyme2
+; RUN: make clean-insertsort_sum-enzyme2 ENZYME_PLUGIN=%loadEnzyme
+

enzyme/functional_tests_c/testfiles/insertsort_sum-enzyme3.test

@@ -0,0 +1,6 @@
+; RUN: cd %desired_wd
+; RUN: make clean-insertsort_sum-enzyme3 ENZYME_PLUGIN=%loadEnzyme
+; RUN: make build/insertsort_sum-enzyme3 ENZYME_PLUGIN=%loadEnzyme CLANG_BIN_PATH=%clangBinPath
+; RUN: build/insertsort_sum-enzyme3
+; RUN: make clean-insertsort_sum-enzyme3 ENZYME_PLUGIN=%loadEnzyme
+

enzyme/test/Enzyme/cppllist.ll

@@ -1,4 +1,4 @@
-; RUN: opt < %s %loadEnzyme -enzyme -enzyme_preopt=false -inline -mem2reg -adce -instcombine -instsimplify -early-cse-memssa -simplifycfg -correlated-propagation -adce -jump-threading -instsimplify -early-cse -simplifycfg -S | FileCheck %s
+; RUN: opt < %s %loadEnzyme -enzyme -enzyme_preopt=false -inline -mem2reg -adce -instcombine -instsimplify -early-cse-memssa -simplifycfg -correlated-propagation -adce -loop-simplify -jump-threading -instsimplify -early-cse -simplifycfg -S | FileCheck %s
 
 ; #include <stdlib.h>
 ; #include <stdio.h>
@@ -233,17 +233,13 @@ attributes #8 = { builtin nounwind }
 ; CHECK: define internal {{(dso_local )?}}{} @diffe_Z8sum_listPK4node(%class.node* noalias readonly %node, %class.node* %"node'", double %[[differet:.+]])
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   %[[cmp:.+]] = icmp eq %class.node* %node, null
-; CHECK-NEXT:   br i1 %[[cmp]], label %invertentry, label %for.body.preheader
-
-; CHECK: for.body.preheader:
-; CHECK-NEXT:   %malloccall = tail call noalias nonnull i8* @malloc(i64 8)
-; CHECK-NEXT:   br label %for.body
+; CHECK-NEXT:   br i1 %[[cmp]], label %invertentry, label %for.body
 
 ; CHECK: for.body:
-; CHECK-NEXT:   %[[rawcache:.+]] = phi i8* [ %malloccall, %for.body.preheader ], [ %_realloccache, %for.body ]
-; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ 0, %for.body.preheader ], [ %[[postidx:.+]], %for.body ]
-; CHECK-NEXT:   %[[cur:.+]] = phi %class.node* [ %"node'", %for.body.preheader ], [ %"'ipl", %for.body ] 
-; CHECK-NEXT:   %val.08 = phi %class.node* [ %node, %for.body.preheader ], [ %[[nextload:.+]], %for.body ]
+; CHECK-NEXT:   %[[rawcache:.+]] = phi i8* [ %_realloccache, %for.body ], [ null, %entry ] 
+; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ %[[postidx:.+]], %for.body ], [ 0, %entry ]
+; CHECK-NEXT:   %[[cur:.+]] = phi %class.node* [ %"'ipl", %for.body ], [ %"node'", %entry ]
+; CHECK-NEXT:   %val.08 = phi %class.node* [ %[[loadst:.+]], %for.body ], [ %node, %entry ]
 ; CHECK-NEXT:   %[[idx8:.+]] = shl i64 %[[preidx]], 3
 ; CHECK-NEXT:   %[[nextrealloc:.+]] = add i64 %[[idx8]], 8
 ; CHECK-NEXT:   %_realloccache = call i8* @realloc(i8* %[[rawcache]], i64 %[[nextrealloc]])
@@ -254,7 +250,7 @@ attributes #8 = { builtin nounwind }
 ; CHECK-NEXT:   %next = getelementptr inbounds %class.node, %class.node* %val.08, i64 0, i32 1
 ; CHECK-NEXT:   %"next'ipg" = getelementptr %class.node, %class.node* %[[cur]], i64 0, i32 1
 ; CHECK-NEXT:   %"'ipl" = load %class.node*, %class.node** %"next'ipg", align 8
-; CHECK-NEXT:   %[[nextload]] = load %class.node*, %class.node** %next, align 8, !tbaa !8
+; CHECK-NEXT:   %[[nextload:.+]] = load %class.node*, %class.node** %next, align 8, !tbaa !8
 ; CHECK-NEXT:   %[[lcmp:.+]] = icmp eq %class.node* %[[nextload]], null
 ; CHECK-NEXT:   br i1 %[[lcmp]], label %[[antiloop:.+]], label %for.body
 

enzyme/test/Enzyme/llist.ll

@@ -1,4 +1,4 @@
-; RUN: opt < %s %loadEnzyme -enzyme -enzyme_preopt=false -inline -mem2reg -adce -instcombine -instsimplify -early-cse-memssa -simplifycfg -correlated-propagation -adce -S -jump-threading -instsimplify -early-cse -simplifycfg | FileCheck %s
+; RUN: opt < %s %loadEnzyme -enzyme -enzyme_preopt=false -inline -mem2reg -adce -instcombine -instsimplify -early-cse-memssa -simplifycfg -correlated-propagation -adce -S -loop-simplify -jump-threading -instsimplify -early-cse -simplifycfg | FileCheck %s
 
 %struct.n = type { double, %struct.n* }
 
@@ -150,15 +150,11 @@ attributes #4 = { nounwind }
 ; CHECK-NEXT:   %cmp6 = icmp eq %struct.n* %node, null
 ; CHECK-NEXT:   br i1 %cmp6, label %invertentry, label %for.body
 
-; CHECK: for.body.preheader:
-; CHECK-NEXT:   %malloccall = tail call noalias nonnull i8* @malloc(i64 8)
-; CHECK-NEXT:   br label %for.body
-
 ; CHECK: for.body:
-; CHECK-NEXT:   %[[rawcache:.+]] = phi i8* [ %malloccall, %for.body.preheader ], [ %_realloccache, %for.body ]
-; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ 0, %for.body.preheader ], [ %[[postidx:.+]], %for.body ]
-; CHECK-NEXT:   %[[cur:.+]] = phi %struct.n* [ %"node'", %for.body.preheader ], [ %"'ipl", %for.body ] 
-; CHECK-NEXT:   %val.08 = phi %struct.n* [ %node, %for.body.preheader ], [ %[[loadst:.+]], %for.body ]
+; CHECK-NEXT:   %[[rawcache:.+]] = phi i8* [ %_realloccache, %for.body ], [ null, %entry ] 
+; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ %[[postidx:.+]], %for.body ], [ 0, %entry ]
+; CHECK-NEXT:   %[[cur:.+]] = phi %struct.n* [ %"'ipl", %for.body ], [ %"node'", %entry ]
+; CHECK-NEXT:   %val.08 = phi %struct.n* [ %[[loadst:.+]], %for.body ], [ %node, %entry ]
 ; CHECK-NEXT:   %[[idx8:.+]] = shl i64 %[[preidx]], 3
 ; CHECK-NEXT:   %[[addalloc:.+]] = add i64 %[[idx8]], 8
 ; CHECK-NEXT:   %_realloccache = call i8* @realloc(i8* %[[rawcache]], i64 %[[addalloc]])

enzyme/test/Enzyme/nllist.ll

@@ -305,17 +305,13 @@ attributes #4 = { nounwind }
 ; CHECK: define internal {{(dso_local )?}}{} @diffesum_list(%struct.n* noalias readonly %node, %struct.n* %"node'", i64 %times, double %differeturn)
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   %[[firstcmp:.+]] = icmp eq %struct.n* %node, null
-; CHECK-NEXT:   br i1 %[[firstcmp]], label %invertentry, label %for.cond1.preheader.preheader
-
-; CHECK: for.cond1.preheader.preheader:                    ; preds = %entry
-; CHECK-NEXT:   %malloccall = tail call noalias nonnull i8* @malloc(i64 8)
-; CHECK-NEXT:   br label %for.cond1.preheader
+; CHECK-NEXT:   br i1 %[[firstcmp]], label %invertentry, label %for.cond1.preheader
 
 ; CHECK: for.cond1.preheader:
-; CHECK-NEXT:   %[[phirealloc:.+]] = phi i8* [ %malloccall, %for.cond1.preheader.preheader ], [ %[[postrealloc:.+]], %for.cond.cleanup4 ]
-; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ 0, %for.cond1.preheader.preheader ], [ %[[postidx:.+]], %for.cond.cleanup4 ] 
-; CHECK-NEXT:   %[[valstruct:.+]] = phi %struct.n* [ %"node'", %for.cond1.preheader.preheader ], [ %[[dstructload:.+]], %for.cond.cleanup4 ] 
-; CHECK-NEXT:   %val.020 = phi %struct.n* [ %node, %for.cond1.preheader.preheader ], [ %[[nextstruct:.+]], %for.cond.cleanup4 ]
+; CHECK-NEXT:   %[[phirealloc:.+]] = phi i8* [ %[[postrealloc:.+]], %for.cond.cleanup4 ], [ null, %entry ] 
+; CHECK-NEXT:   %[[preidx:.+]] = phi i64 [ %[[postidx:.+]], %for.cond.cleanup4 ], [ 0, %entry ]
+; CHECK-NEXT:   %[[valstruct:.+]] = phi %struct.n* [ %[[dstructload:.+]], %for.cond.cleanup4 ], [ %"node'", %entry ]
+; CHECK-NEXT:   %val.020 = phi %struct.n* [ %[[nextstruct:.+]], %for.cond.cleanup4 ], [ %node, %entry ]
 ; CHECK-NEXT:   %[[postidx]] = add nuw i64 %[[preidx]], 1
 ; CHECK-NEXT:   %[[added:.+]] = shl nuw i64 %[[postidx]], 3
 ; CHECK-NEXT:   %[[postrealloc]] = call i8* @realloc(i8* %[[phirealloc]], i64 %[[added]])