[Concurrency] First steps towards async CC.

Here, the following is implemented:
- Construction of SwiftContext struct with the fields needed for calling
  functions.
- Allocating and deallocating these swift context via runtime calls
  before calling async functions and after returning from them.
- Storing arguments (including bindings and the self parameter but not
  including protocol fields for witness methods) and returns (both
  direct and indirect).
- Calling async functions.

Additional things that still need to be done:
- protocol extension methods
- protocol witness methods
- storing yields
- partial applies

Author: nate-chandler

lib/IRGen/CallEmission.h

@@ -33,10 +33,15 @@ struct WitnessMetadata;
 
 /// A plan for emitting a series of calls.
 class CallEmission {
+  enum class State { Emitting, Finished };
+  State state = State::Emitting;
+
 public:
   IRGenFunction &IGF;
 
-private:
+protected:
+  llvm::Value *selfValue;
+
   /// The builtin/special arguments to pass to the call.
   SmallVector<llvm::Value*, 8> Args;
 
@@ -57,31 +62,35 @@ class CallEmission {
   /// RemainingArgsForCallee, at least between calls.
   bool EmittedCall;
 
-  void setFromCallee();
+  virtual void setFromCallee();
   void emitToUnmappedMemory(Address addr);
   void emitToUnmappedExplosion(Explosion &out);
+  virtual void emitCallToUnmappedExplosion(llvm::CallInst *call, Explosion &out) = 0;
   void emitYieldsToExplosion(Explosion &out);
   llvm::CallInst *emitCallSite();
 
+  CallEmission(IRGenFunction &IGF, llvm::Value *selfValue, Callee &&callee)
+      : IGF(IGF), selfValue(selfValue), CurCallee(std::move(callee)) {}
+
 public:
-  CallEmission(IRGenFunction &IGF, Callee &&callee)
-      : IGF(IGF), CurCallee(std::move(callee)) {
-    setFromCallee();
-  }
   CallEmission(const CallEmission &other) = delete;
   CallEmission(CallEmission &&other);
   CallEmission &operator=(const CallEmission &other) = delete;
-  ~CallEmission();
+  virtual ~CallEmission();
 
   const Callee &getCallee() const { return CurCallee; }
 
   SubstitutionMap getSubstitutions() const {
     return CurCallee.getSubstitutions();
   }
 
+  virtual void begin();
+  virtual void end();
+  virtual SILType getParameterType(unsigned index) = 0;
   /// Set the arguments to the function from an explosion.
-  void setArgs(Explosion &arg, bool isOutlined,
-               WitnessMetadata *witnessMetadata = nullptr);
+  virtual void setArgs(Explosion &arg, bool isOutlined,
+                       WitnessMetadata *witnessMetadata);
+  virtual Address getCalleeErrorSlot(SILType errorType) = 0;
 
   void addAttribute(unsigned Index, llvm::Attribute::AttrKind Attr);
 
@@ -100,6 +109,9 @@ class CallEmission {
   }
 };
 
+std::unique_ptr<CallEmission>
+getCallEmission(IRGenFunction &IGF, llvm::Value *selfValue, Callee &&callee);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/EntryPointArgumentEmission.h

@@ -0,0 +1,46 @@
+//===-- EntryPointArgumentEmission.h - Emit function entries. -------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace llvm {
+class Value;
+}
+
+namespace swift {
+namespace irgen {
+
+class Explosion;
+
+class EntryPointArgumentEmission {
+
+public:
+  virtual ~EntryPointArgumentEmission() {}
+  virtual bool requiresIndirectResult(SILType retType) = 0;
+  virtual llvm::Value *getIndirectResultForFormallyDirectResult() = 0;
+  virtual llvm::Value *getIndirectResult(unsigned index) = 0;
+};
+
+class NativeCCEntryPointArgumentEmission
+    : public virtual EntryPointArgumentEmission {
+
+public:
+  virtual llvm::Value *getCallerErrorResultArgument() = 0;
+  virtual llvm::Value *getContext() = 0;
+  virtual Explosion getArgumentExplosion(unsigned index, unsigned size) = 0;
+  virtual llvm::Value *getSelfWitnessTable() = 0;
+  virtual llvm::Value *getSelfMetadata() = 0;
+  virtual llvm::Value *getCoroutineBuffer() = 0;
+};
+
+} // end namespace irgen
+} // end namespace swift

lib/IRGen/Explosion.h

@@ -152,6 +152,11 @@ class Explosion {
     return Values[NextValue-1];
   }
 
+  llvm::Value *peek(unsigned n) {
+    assert(n < Values.size());
+    return Values[n];
+  }
+
   /// Claim and remove the last item in the array.
   /// Unlike the normal 'claim' methods, the item is gone forever.
   llvm::Value *takeLast() {

lib/IRGen/GenBuiltin.cpp

@@ -408,10 +408,10 @@ if (Builtin.ID == BuiltinValueKind::id) { \
 
     auto *fn = cast<llvm::Function>(IGF.IGM.getWillThrowFn());
     auto error = args.claimNext();
-    auto errorBuffer = IGF.getErrorResultSlot(
-               SILType::getPrimitiveObjectType(IGF.IGM.Context.getErrorDecl()
-                                                  ->getDeclaredInterfaceType()
-                                                  ->getCanonicalType()));
+    auto errorBuffer = IGF.getCalleeErrorResultSlot(
+        SILType::getPrimitiveObjectType(IGF.IGM.Context.getErrorDecl()
+                                            ->getDeclaredInterfaceType()
+                                            ->getCanonicalType()));
     IGF.Builder.CreateStore(error, errorBuffer);
 
     auto context = llvm::UndefValue::get(IGF.IGM.Int8PtrTy);