Implement IR generation for the 'foreach' loop and convert our fractal

examples over to using the 'foreach' loop. Addresses
<rdar://problem/11259997>.


Swift SVN r1606

Author: DougGregor

lib/IRGen/GenControl.cpp

@@ -22,6 +22,7 @@
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
 #include "JumpDest.h"
+#include "Scope.h"
 
 using namespace swift;
 using namespace irgen;
@@ -99,11 +100,15 @@ IRGenFunction::createBasicBlock(const llvm::Twine &Name) {
 ///
 /// \param hasFalseCode - true if the false branch doesn't just lead
 /// to the fallthrough.
-Condition IRGenFunction::emitCondition(Expr *E, bool hasFalseCode) {
+/// \param invertValue - true if this routine should invert the value before
+/// testing true/false.
+Condition IRGenFunction::emitCondition(Expr *E, bool hasFalseCode,
+                                       bool invertValue) {
   assert(Builder.hasValidIP() && "emitting condition at unreachable point");
 
   // Sema forces conditions to have Builtin.i1 type, which guarantees this.
   // TODO: special-case interesting condition expressions.
+  FullExpr Scope(*this);
   llvm::Value *V = emitAsPrimitiveScalar(E);
   assert(V->getType()->isIntegerTy(1));
 
@@ -113,7 +118,7 @@ Condition IRGenFunction::emitCondition(Expr *E, bool hasFalseCode) {
   if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(V)) {
     // If the condition is constant false, ignore the true branch.  We
     // will fall into the false branch unless there is none.
-    if (C->isZero()) {
+    if (C->isZero() == !invertValue) {
       trueBB = nullptr;
       falseBB = (hasFalseCode ? Builder.GetInsertBlock() : nullptr);
 
@@ -129,6 +134,12 @@ Condition IRGenFunction::emitCondition(Expr *E, bool hasFalseCode) {
 
   // Otherwise, the condition requires a conditional branch.
   } else {
+    // If requested, invert the value.
+    if (invertValue)
+      V = Builder.CreateXor(V,
+                            llvm::Constant::getIntegerValue(IGM.Int1Ty,
+                                                            llvm::APInt(1, 1)));
+    
     contBB = createBasicBlock("condition.cont");
     trueBB = createBasicBlock("if.true");
 

lib/IRGen/GenStmt.cpp

@@ -25,9 +25,6 @@
 #include "JumpDest.h"
 #include "LValue.h"
 
-// FIXME: Temporary
-#include "IRGenModule.h"
-
 using namespace swift;
 using namespace irgen;
 
@@ -57,8 +54,7 @@ void IRGenFunction::emitStmt(Stmt *S) {
     return emitForStmt(cast<ForStmt>(S));
 
   case StmtKind::ForEach:
-    IGM.unimplemented(S->getStartLoc(), "foreach loop");
-    return;
+    return emitForEachStmt(cast<ForEachStmt>(S));
   }
   llvm_unreachable("bad statement kind!");
 }
@@ -205,4 +201,46 @@ void IRGenFunction::emitForStmt(ForStmt *S) {
 
 }
 
+void IRGenFunction::emitForEachStmt(ForEachStmt *S) {
+  FullExpr Scope(*this);
+  
+  // Emit the 'range' variable that we'll be using for iteration.
+  emitPatternBindingDecl(S->getRange());
+  
+  // If we ever reach an unreachable point, stop emitting statements.
+  // This will need revision if we ever add goto.
+  if (!Builder.hasValidIP()) return;
+
+  // Create a new basic block and jump into it.
+  llvm::BasicBlock *LoopBB = createBasicBlock("foreach.cond");
+  Builder.CreateBr(LoopBB);
+  Builder.emitBlock(LoopBB);
+
+  Condition Cond = emitCondition(S->getRangeEmpty(), /*hasFalseCode=*/false,
+                                 /*invertValue=*/true);
+  if (Cond.hasTrue()) {
+    Cond.enterTrue(*this);
+
+    // Emit the loop body.
+    FullExpr Scope(*this);
+    emitPatternBindingDecl(S->getElementInit());
+    emitStmt(S->getBody());
+
+    // Drop the first element in the range
+    if (Builder.hasValidIP()) {
+      FullExpr Scope(*this);
+      emitIgnored(S->getRangeDropFirst());
+    }
+    
+    // Loop back to the header.
+    if (Builder.hasValidIP()) {
+      Builder.CreateBr(LoopBB);
+      Builder.ClearInsertionPoint();
+    }
+    Cond.exitTrue(*this);
+  }
+  
+  // Complete the conditional execution.
+  Cond.complete(*this);  
+}
 

lib/IRGen/IRGenFunction.h

@@ -286,15 +286,12 @@ class IRGenFunction {
                   const TypeInfo &type);
   void emitAssign(Expr *E, const LValue &lvalue, const TypeInfo &type);
 
-  void emitPatternBindingInit(Pattern *P, Expr *E, bool isGlobal);
-  void emitPatternBindingInit(Pattern *P, Explosion &E, bool isGlobal);
-
   OwnedAddress getAddrForParameter(VarDecl *param, Explosion &paramValues);
 
   void emitNullaryCall(llvm::Value *fn, Type resultType, Explosion &result);
 
 private:
-  Condition emitCondition(Expr *E, bool hasFalseCode);
+  Condition emitCondition(Expr *E, bool hasFalseCode, bool invertValue = false);
 
 //--- Declaration emission -----------------------------------------------------
 public:

lib/Sema/TypeCheckStmt.cpp

@@ -256,22 +256,24 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 
     // Compute the expression that determines whether the range is empty.
     Expr *Empty
-      = callNullaryMethodOf(new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
-                                                         RangeTy),
-                            TC.Context.getIdentifier("empty"),
-                            S->getInLoc(), diag::foreach_range_empty,
-                            diag::foreach_nonfunc_range_empty);
+      = callNullaryMethodOf(
+          new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
+                                       Range->getTypeOfReference()),
+          TC.Context.getIdentifier("empty"),
+          S->getInLoc(), diag::foreach_range_empty,
+          diag::foreach_nonfunc_range_empty);
     if (!Empty) return nullptr;
     if (TC.typeCheckCondition(Empty)) return nullptr;
     S->setRangeEmpty(Empty);
 
     // Compute the expression that extracts a value from the range.
     Expr *GetFirst
-      = callNullaryMethodOf(new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
-                                                         RangeTy),
-                            TC.Context.getIdentifier("getFirst"),
-                            S->getInLoc(), diag::foreach_range_getfirst,
-                            diag::foreach_nonfunc_range_getfirst);
+      = callNullaryMethodOf(
+          new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
+                                       Range->getTypeOfReference()),
+          TC.Context.getIdentifier("getFirst"),
+          S->getInLoc(), diag::foreach_range_getfirst,
+          diag::foreach_nonfunc_range_getfirst);
     if (!GetFirst) return nullptr;
 
     // Make sure our element type is materializable.
@@ -293,11 +295,12 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 
     // Compute the expression that drops the first value from the range.
     Expr *DropFirst
-      = callNullaryMethodOf(new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
-                                                         RangeTy),
-                            TC.Context.getIdentifier("dropFirst"),
-                            S->getInLoc(), diag::foreach_range_dropfirst,
-                            diag::foreach_nonfunc_range_dropfirst);
+      = callNullaryMethodOf(
+          new (TC.Context) DeclRefExpr(Range, S->getInLoc(),
+                                       Range->getTypeOfReference()),
+          TC.Context.getIdentifier("dropFirst"),
+          S->getInLoc(), diag::foreach_range_dropfirst,
+          diag::foreach_nonfunc_range_dropfirst);
     if (!DropFirst) return nullptr;
     S->setRangeDropFirst(DropFirst);
 

test/IRGen/foreach.swift

@@ -0,0 +1,23 @@
+// RUN: %swift -triple x86_64-apple-darwin10 -I %S/.. %s -emit-llvm | FileCheck %s
+
+import swift
+
+// CHECK: define void @_T7foreach12foreach_testFT1rNSs5Range_T_(
+func foreach_test(r : Range) {
+  var sum : Int = 0
+  // CHECK: call { i64, i64 } @_TNSs5Range11getElementsfRS_FT_S_
+  // CHECK: br label
+  // CHECK: call i1 @_TNSs5Range5emptyfRS_FT_NSs4Bool
+  // CHECK: call i1 @_TNSs4Bool13getLogicValuefRS_FT_i1
+  // CHECK-NEXT: [[RESULT:%[A-Za-z0-9.]+]] = xor
+  // CHECK: br i1 [[RESULT]], label
+  foreach i in r {
+    // CHECK: call i64 @_TNSs5Range8getFirstfRS_FT_NSs5Int64
+    // CHECK: call i64 @_TSsop1pFT3lhsNSs5Int643rhsS__S_
+    sum = sum + i
+    // CHECK: call void @_TNSs5Range9dropFirstfRS_FT_T_
+    // CHECK-NEXT: br label
+  }
+
+  // CHECK: ret void
+}