IRGen: Emit a weak reference to swift_async_extendedFramePointerFlags when neccessary

When we deploy to a minimum target that is not known to support extended
frame information the function prolog of Swift async functions will
contain a reference to swift_async_extendedFramePointerFlags. This
reference needs to be weak like any async symbols.

rdar://83412550
(cherry picked from commit 16a5d69)

Author: aschwaighofer

lib/IRGen/IRGenModule.cpp

@@ -1610,6 +1610,7 @@ bool IRGenModule::finalize() {
   if (!ClangCodeGen->GetModule())
     return false;
 
+  emitSwiftAsyncExtendedFrameInfoWeakRef();
   emitAutolinkInfo();
   emitGlobalLists();
   if (DebugInfo)
@@ -1742,3 +1743,45 @@ TypeExpansionContext IRGenModule::getMaximalTypeExpansionContext() const {
 const TypeLayoutEntry &IRGenModule::getTypeLayoutEntry(SILType T) {
   return Types.getTypeLayoutEntry(T);
 }
+
+/// Return whether FrameLowering should always set the "extended frame
+/// present" bit in FP, or set it based on a symbol in the runtime.
+static bool isSwiftAsyncContextIsDynamicallySet(llvm::Triple TT) {
+  // Older OS versions (particularly system unwinders) are confused by the
+  // Swift extended frame, so when building code that might be run on them we
+  // must dynamically query the concurrency library to determine whether
+  // extended frames should be flagged as present.
+  unsigned Major, Minor, Micro;
+  TT.getOSVersion(Major, Minor, Micro);
+  switch(TT.getOS()) {
+  default:
+    return false;
+  case llvm::Triple::IOS:
+  case llvm::Triple::TvOS:
+    return Major < 15;
+  case llvm::Triple::WatchOS:
+    return Major < 8;
+  case llvm::Triple::MacOSX:
+  case llvm::Triple::Darwin:
+    return Major < 12;
+  }
+}
+
+void IRGenModule::emitSwiftAsyncExtendedFrameInfoWeakRef() {
+  if (!hasSwiftAsyncFunctionDef || extendedFramePointerFlagsWeakRef)
+    return;
+  if (IRGen.Opts.SwiftAsyncFramePointer !=
+      SwiftAsyncFramePointerKind::Auto)
+    return;
+  if (!isSwiftAsyncContextIsDynamicallySet(Triple))
+    return;
+
+  // Emit a weak reference to the `swift_async_extendedFramePointerFlags` symbol
+  // needed by Swift async functions.
+  auto symbolName = "swift_async_extendedFramePointerFlags";
+  if ((extendedFramePointerFlagsWeakRef = Module.getGlobalVariable(symbolName)))
+    return;
+  extendedFramePointerFlagsWeakRef = new llvm::GlobalVariable(Module, Int8PtrTy, false,
+                                         llvm::GlobalValue::ExternalWeakLinkage, nullptr,
+                                         symbolName);
+}

lib/IRGen/IRGenModule.h

@@ -1691,7 +1691,16 @@ private:                            \
   void addLazyConformances(const IterableDeclContext *idc);
 
 //--- Global context emission --------------------------------------------------
+  bool hasSwiftAsyncFunctionDef = false;
+  llvm::Value *extendedFramePointerFlagsWeakRef = nullptr;
+
+  /// Emit a weak reference to the `swift_async_extendedFramePointerFlags`
+  /// symbol needed by Swift async functions.
+  void emitSwiftAsyncExtendedFrameInfoWeakRef();
 public:
+  void noteSwiftAsyncFunctionDef() {
+    hasSwiftAsyncFunctionDef = true;
+  }
   void emitRuntimeRegistration();
   void emitVTableStubs();
   void emitTypeVerifier();

lib/IRGen/IRGenSIL.cpp

@@ -2183,12 +2183,16 @@ void IRGenSILFunction::emitSILFunction() {
     IGM.IRGen.addDynamicReplacement(CurSILFn);
 
   auto funcTy = CurSILFn->getLoweredFunctionType();
-  if (funcTy->isAsync() && funcTy->getLanguage() == SILFunctionLanguage::Swift) {
+  bool isAsyncFn = funcTy->isAsync();
+  if (isAsyncFn && funcTy->getLanguage() == SILFunctionLanguage::Swift) {
     emitAsyncFunctionPointer(IGM,
                              CurFn,
                              LinkEntity::forSILFunction(CurSILFn),
                              getAsyncContextLayout(*this).getSize());
   }
+  if (isAsyncFn) {
+    IGM.noteSwiftAsyncFunctionDef();
+  }
 
   // Configure the dominance resolver.
   // TODO: consider re-using a dom analysis from the PassManager

test/IRGen/swift_async_extended_frame_info.swift

@@ -21,3 +21,7 @@ public func someAsyncFunction() async {
 // NEVER: s31swift_async_extended_frame_info17someAsyncFunctionyyYaF:
 // NEVER-NOT:	_swift_async_extendedFramePointerFlags
 // NEVER-NOT: btsq	$60
+
+// AUTO: .weak_reference _swift_async_extendedFramePointerFlags
+// NEVER-NOT: .weak_reference _swift_async_extendedFramePointerFlags
+// ALWAYS-NOT: .weak_reference _swift_async_extendedFramePointerFlags