Merge remote-tracking branch 'origin/master' into master-next

Author: bob-wilson

CMakeLists.txt

@@ -105,7 +105,7 @@ set(SWIFT_ANALYZE_CODE_COVERAGE FALSE CACHE STRING
 set_property(CACHE SWIFT_ANALYZE_CODE_COVERAGE PROPERTY
     STRINGS FALSE "NOT-MERGED" "MERGED")
 
-set(SWIFT_VERSION "3.1" CACHE STRING
+set(SWIFT_VERSION "4.0" CACHE STRING
     "The user-visible version of the Swift compiler")
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")

lib/LLVMPasses/LLVMMergeFunctions.cpp

@@ -782,20 +782,31 @@ bool SwiftMergeFunctions::deriveParams(ParamInfos &Params,
 
 /// Returns true if the \p OpIdx's constant operand in the current instruction
 /// does differ in any of the functions in \p FInfos.
+///
+/// But it accepts the case where all operands refer to their containing
+/// functions (in case of self recursive functions).
 bool SwiftMergeFunctions::constsDiffer(const FunctionInfos &FInfos,
                                        unsigned OpIdx) {
   Constant *CommonConst = nullptr;
+  bool matching = true;
+  bool selfReferencing = true;
 
   for (const FunctionInfo &FI : FInfos) {
     Value *Op = FI.CurrentInst->getOperand(OpIdx);
     if (Constant *C = dyn_cast<Constant>(Op)) {
+      if (C != FI.F)
+        selfReferencing = false;
+
       if (!CommonConst) {
         CommonConst = C;
       } else if (C != CommonConst) {
-        return true;
+        matching = false;
       }
+      if (!selfReferencing && !matching)
+        return true;
     }
   }
+  assert(selfReferencing || matching);
   return false;
 }
 
@@ -903,6 +914,7 @@ void SwiftMergeFunctions::mergeWithParams(const FunctionInfos &FInfos,
       assert(!isInEquivalenceClass(&*Iter->second));
       Iter->second->F = nullptr;
       FuncEntries.erase(Iter);
+      DEBUG(dbgs() << "    Erase " << OrigFunc->getName() << '\n');
       OrigFunc->eraseFromParent();
     } else {
       // Otherwise we need a thunk which calls the merged function.
@@ -1062,8 +1074,15 @@ bool SwiftMergeFunctions::replaceDirectCallers(Function *Old, Function *New,
     // Add the new parameters.
     for (const ParamInfo &PI : Params) {
       assert(ParamIdx < NewFuncTy->getNumParams());
-      NewArgs.push_back(PI.Values[FuncIdx]);
-      OldParamTypes.push_back(PI.Values[FuncIdx]->getType());
+      Constant *ArgValue = PI.Values[FuncIdx];
+
+      // Check if it's a self referencing function. We must not use the old
+      // function pointer as argument.
+      if (ArgValue == Old)
+        ArgValue = New;
+
+      NewArgs.push_back(ArgValue);
+      OldParamTypes.push_back(ArgValue->getType());
       ++ParamIdx;
     }
 
@@ -1080,6 +1099,7 @@ bool SwiftMergeFunctions::replaceDirectCallers(Function *Old, Function *New,
     CI->replaceAllUsesWith(NewCI);
     CI->eraseFromParent();
   }
+  assert(Old->use_empty() && "should have replaced all uses of old function");
   return Old->hasLocalLinkage();
 }
 

test/LLVMPasses/merge_func.ll

@@ -323,3 +323,72 @@ done:
 ; CHECK: ret i1
   ret i1 %result
 }
+
+; Check self recursive functions
+
+; CHECK-NOT: @recursive1(
+define internal void @recursive1(i32 %x, i32 %y) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @recursive1(i32 %x, i32 %y)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define internal void @recursive1_merged(i32, i32)
+; CHECK: call void @recursive1_merged(i32 %0, i32 %1)
+; CHECK: ret void
+define internal void @recursive2(i32 %x, i32 %y) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @recursive2(i32 %x, i32 %y)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define internal void @another_recursive_func_merged(i32, void (i32)*)
+; CHECK: call void %1(i32 %0)
+; CHECK: ret void
+define internal void @another_recursive_func(i32 %x) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @another_recursive_func(i32 %x)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-NOT: @not_really_recursive(
+define internal void @not_really_recursive(i32 %x) {
+  br i1 undef, label %bb1, label %bb2
+
+bb1:
+  call void @callee1(i32 %x)
+  br label %bb2
+
+bb2:
+  ret void
+}
+
+; CHECK-LABEL: define void @call_recursive_funcs(i32 %x)
+; CHECK: call void @recursive1_merged(i32 %x, i32 %x)
+; CHECK: call void @recursive1_merged(i32 %x, i32 %x)
+; CHECK: call void bitcast (void (i32, void (i32)*)* @another_recursive_func_merged to void (i32, void (i32, void (i32)*)*)*)(i32 %x, void (i32, void (i32)*)* @another_recursive_func_merged)
+; CHECK: call void @another_recursive_func_merged(i32 %x, void (i32)* @callee1)
+; CHECK: ret void
+define void @call_recursive_funcs(i32 %x) {
+  call void @recursive1(i32 %x, i32 %x)
+  call void @recursive2(i32 %x, i32 %x)
+  call void @another_recursive_func(i32 %x)
+  call void @not_really_recursive(i32 %x)
+  ret void
+}
+

utils/build-script-impl

@@ -174,7 +174,7 @@ KNOWN_SETTINGS=(
     native-swift-tools-path     ""               "directory that contains Swift tools that are executable on the build machine"
     compiler-vendor             "none"           "compiler vendor name [none,apple]"
     clang-user-visible-version  "5.0.0"          "user-visible version of the embedded Clang and LLVM compilers"
-    swift-user-visible-version  "3.1"            "user-visible version of the Swift language"
+    swift-user-visible-version  "4.0"            "user-visible version of the Swift language"
     swift-compiler-version      ""               "string that indicates a compiler version for Swift"
     clang-compiler-version      ""               "string that indicates a compiler version for Clang"
     embed-bitcode-section       "0"              "embed an LLVM bitcode section in stdlib/overlay binaries for supported platforms"