[IROutliner] Adding support for swift errors

[AndrewLitteken]

Summary

Since some values can be swift errors, we need to make sure that we correctly propagate the parameter attributes.

Tests found at:
llvm/test/Transforms/IROutliner/outlining-swift-error.ll

[jroelofs]

llvm/lib/Transforms/IPO/IROutliner.cpp

795–797

With Optionals, we usually avoid calling hasValue()/getValue() most of the time, and instead treat them as if they had pointer semantics. Subjectively, this increases readability.

llvm/lib/Transforms/IPO/IROutliner.cpp

struct OutlinableGroup {
 
   /// The number of instructions that will be outlined by extracting \ref
   /// Regions.
   unsigned Benefit = 0;
   /// The number of added instructions needed for the outlining of the \ref
   /// Regions.
   unsigned Cost = 0;
 
+  /// The argument that needs to be marked with the swifterr attribute.  If not
+  /// needed, there is no value.
+  Optional<unsigned> SwiftErrorArgument;
+
   /// For the \ref Regions, we look at every Value.  If it is a constant,
   /// we check whether it is the same in Region.
   ///
   /// \param [in,out] NotSame contains the global value numbers where the
   /// constant is not always the same, and must be passed in as an argument.
   void findSameConstants(DenseSet<unsigned> &NotSame);
 
   /// For the regions, look at each set of GVN stores needed and account for
Group.OutlinedFunctionType = FunctionType::get(
       Type::getVoidTy(M.getContext()), Group.ArgumentTypes, false);
 
   // These functions will only be called from within the same module, so
   // we can set an internal linkage.
   Group.OutlinedFunction = Function::Create(
       Group.OutlinedFunctionType, GlobalValue::InternalLinkage,
       "outlined_ir_func_" + std::to_string(FunctionNameSuffix), M);
 
+  // Transfer the swifterr attribute to the correct function parameter.
+  if (Group.SwiftErrorArgument.hasValue())
+    Group.OutlinedFunction->addParamAttr(Group.SwiftErrorArgument.getValue(),
+                                         Attribute::SwiftError);
+
   Group.OutlinedFunction->addFnAttr(Attribute::OptimizeForSize);
   Group.OutlinedFunction->addFnAttr(Attribute::MinSize);
 
   return Group.OutlinedFunction;
 }
 
 /// Move each BasicBlock in \p Old to \p New.
 ///
findExtractedInputToOverallInputMapping(OutlinableRegion &Region,
   // function to account for the extracted constants, we have two different
   // counters as we find extracted arguments, and as we come across overall
   // arguments.
   for (unsigned InputVal : InputGVNs) {
     Optional<Value *> InputOpt = C.fromGVN(InputVal);
     assert(InputOpt.hasValue() && "Global value number not found?");
     Value *Input = InputOpt.getValue();
 
-    if (!Group.InputTypesSet)
+    if (!Group.InputTypesSet) {
       Group.ArgumentTypes.push_back(Input->getType());
+      // If the input value has a swifterr attribute, make sure to mark the
+      // argument in the overall function.
+      if (Input->isSwiftError()) {
+        assert(
+            !Group.SwiftErrorArgument.hasValue() &&
+            "Argument already marked with swifterr for this OutlinableGroup!");
+        Group.SwiftErrorArgument = TypeIndex;
+      }
+    }
 
     // Check if we have a constant. If we do add it to the overall argument
     // number to Constant map for the region, and continue to the next input.
     if (Constant *CST = dyn_cast<Constant>(Input)) {
       Region.AggArgToConstant.insert(std::make_pair(TypeIndex, CST));
       TypeIndex++;
       continue;
     }
NewCallArgs.push_back(ConstantPointerNull::get(
         static_cast<PointerType *>(AggFunc->getArg(AggArgIdx)->getType())));
   }
 
   LLVM_DEBUG(dbgs() << "Replace call to " << *Call << " with call to "
                     << *AggFunc << " with new set of arguments\n");
   // Create the new call instruction and erase the old one.
   Call = CallInst::Create(AggFunc->getFunctionType(), AggFunc, NewCallArgs, "",
                           Call);
 
   // It is possible that the call to the outlined function is either the first
   // instruction is in the new block, the last instruction, or both.  If either
   // of these is the case, we need to make sure that we replace the instruction
   // in the IRInstructionData struct with the new call.
   CallInst *OldCall = Region.Call;
   if (Region.NewFront->Inst == OldCall)
     Region.NewFront->Inst = Call;
   if (Region.NewBack->Inst == OldCall)
     Region.NewBack->Inst = Call;
 
   // Transfer any debug information.
   Call->setDebugLoc(Region.Call->getDebugLoc());
 
   // Remove the old instruction.
   OldCall->eraseFromParent();
   Region.Call = Call;
 
+  // Make sure that the argument in the new function has the SwiftError
+  // argument.
+  if (Group.SwiftErrorArgument.hasValue())
+    Call->addParamAttr(Group.SwiftErrorArgument.getValue(),
+                       Attribute::SwiftError);
+
   return Call;
 }
 
 // Within an extracted function, replace the argument uses of the extracted
 // region with the arguments of the function for an OutlinableGroup.
 //
 /// \param [in] Region - The region of extracted code to be changed.
 /// \param [in,out] OutputBB - The BasicBlock for the output stores for this

llvm/test/Transforms/IROutliner/outlining-swift-error.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+%swift.error = type opaque
+
+define void @outlining_swifterror1(%swift.error** swifterror %err) {
+; CHECK-LABEL: @outlining_swifterror1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[X:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    call void @outlined_ir_func_0(i64 5, i64* [[X]], %swift.error** swifterror [[ERR:%.*]])
+; CHECK-NEXT:    ret void
+;
+entry:
+  %x = alloca i64
+  %0 = mul i64 5, 5
+  %1 = add i64 %0, %0
+  store i64 %1, i64* %x
+  %casted = bitcast i64* %x to %swift.error*
+  store %swift.error* %casted, %swift.error** %err
+  ret void
+}
+
+define void @outlining_swifterror2(%swift.error** swifterror %err) {
+; CHECK-LABEL: @outlining_swifterror2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[X:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    call void @outlined_ir_func_0(i64 3, i64* [[X]], %swift.error** swifterror [[ERR:%.*]])
+; CHECK-NEXT:    ret void
+;
+entry:
+  %x = alloca i64
+  %0 = mul i64 3, 3
+  %1 = add i64 %0, %0
+  store i64 %1, i64* %x
+  %casted = bitcast i64* %x to %swift.error*
+  store %swift.error* %casted, %swift.error** %err
+  ret void
+}
+
+; CHECK: define internal void @outlined_ir_func_0(i64 [[ARG0:%.*]], i64* [[ARG1:%.*]], %swift.error** swifterror [[ARG2:%.*]])
+; CHECK: entry_to_outline:
+; CHECK-NEXT:  [[TMP0:%.*]] = mul i64 [[ARG0]], [[ARG0]]
+; CHECK-NEXT:  [[TMP1:%.*]] = add i64 [[TMP0]], [[TMP0]]
+; CHECK-NEXT:  store i64 [[TMP1]], i64* [[ARG1]], align 4
+; CHECK-NEXT:  %casted = bitcast i64* [[ARG1]] to %swift.error*
+; CHECK-NEXT:  store %swift.error* %casted, %swift.error** [[ARG2]], align 8
+; CHECK-NEXT:  br label %entry_after_outline.exitStub