[SILGen] Consistently use SIL asmname for foreign function/variable references

Whenever we have a reference to a foreign function/variable in SIL, use
a mangled name at the SIL level with the C name in the asmname
attribute. The expands the use of asmname to three kinds of cases that
it hadn't been used in yet:

* Declarations imported from C headers/modules
* @_cdecl @implementation of C headers/modules
* @_cdecl functions in general

Some code within the SIL pipeline makes assumptions that the C names of
various runtime functions are reflected at the SIL level. For example,
the linking of Embedded Swift runtime functions is done by-name, and
some of those names refer to C functions (like `swift_retain`) and
others refer to Swift functions that use `@_silgen_name` (like
`swift_getDefaultExecutor`). Extend the serialized module format to
include a table that maps from the asmname of functions/variables over
to their mangled names, so we can look up functions by asmname if we
want. These tables could also be used for checking for declarations
that conflict on their asmname in the future. Right now, we leave it
up to LLVM or the linker to do the checking.

`@_silgen_name` is not affected by these changes, nor should it be:
that hidden feature is specifically meant to affect the name at the
SIL level.

The vast majority of test changes are SIL tests where we had expected
to see the C/C++/Objective-C names in the tests for references to
foreign entities, and now we see Swift mangled names (ending in To).
The SIL declarations themselves will have a corresponding asmname.

Notably, the IRGen tests have *not* changed, because we generally the
same IR as before. It's only the modeling at the SIL lever that has
changed.

Another part of rdar://137014448.

Author: DougGregor

include/swift/AST/Attr.h

@@ -3126,8 +3126,8 @@ class ExternAttr : public DeclAttribute {
   }
 
   /// Returns the C name of the given declaration.
-  /// \p forDecl is the func decl that the attribute belongs to.
-  StringRef getCName(const FuncDecl *forDecl) const;
+  /// \p forDecl is the decl that the attribute belongs to.
+  StringRef getCName(const ValueDecl *forDecl) const;
 
   /// Find an ExternAttr with the given kind in the given DeclAttributes.
   static const ExternAttr *find(const DeclAttributes &attrs, ExternKind kind);

include/swift/SIL/SILDeclRef.h

@@ -335,7 +335,7 @@ struct SILDeclRef {
 
   /// If the symbol has a specific name for use at the LLVM IR level,
   /// produce that name. This may be different than the mangled name in SIL.
-  std::optional<StringRef> getAsmName() const;
+  std::optional<std::string> getAsmName() const;
 
   /// True if the SILDeclRef references a function.
   bool isFunc() const {

include/swift/SIL/SILFunction.h

@@ -1430,7 +1430,7 @@ class SILFunction
 
   /// Return custom assembler name, otherwise empty.
   StringRef asmName() const { return AsmName; }
-  void setAsmName(StringRef value) { AsmName = value; }
+  void setAsmName(StringRef value);
 
   /// Return custom section name if @section was used, otherwise empty
   StringRef section() const { return Section; }

include/swift/SIL/SILGlobalVariable.h

@@ -160,7 +160,7 @@ class SILGlobalVariable
 
   /// Return custom assembler name, otherwise empty.
   StringRef asmName() const { return AsmName; }
-  void setAsmName(StringRef value) { AsmName = value; }
+  void setAsmName(StringRef value);
 
   /// Return custom section name if @section was used, otherwise empty
   StringRef section() const { return Section; }

include/swift/SIL/SILModule.h

@@ -235,6 +235,10 @@ class SILModule {
   llvm::StringMap<SILFunction *> FunctionTable;
   llvm::StringMap<SILFunction *> ZombieFunctionTable;
 
+  /// Lookup table for SIL functions by their asmnames, for those that
+  /// have them.
+  llvm::StringMap<SILFunction *> FunctionByAsmNameTable;
+
   /// The list of SILFunctions in the module.
   FunctionListType functions;
 
@@ -310,6 +314,9 @@ class SILModule {
   /// Lookup table for SIL Global Variables.
   llvm::StringMap<SILGlobalVariable *> GlobalVariableMap;
 
+  /// Lookup table for SIL Global Variables, indexed by their asmnames.
+  llvm::StringMap<SILGlobalVariable *> GlobalVariableByAsmNameMap;
+
   /// The list of SILGlobalVariables in the module.
   GlobalListType silGlobals;
 
@@ -822,14 +829,20 @@ class SILModule {
   /// Look for a global variable by name.
   ///
   /// \return null if this module has no such global variable
-  SILGlobalVariable *lookUpGlobalVariable(StringRef name) const {
+  SILGlobalVariable *lookUpGlobalVariable(StringRef name,
+                                          bool byAsmName = false) const {
+    if (byAsmName)
+      return GlobalVariableByAsmNameMap.lookup(name);
+
     return GlobalVariableMap.lookup(name);
   }
 
   /// Look for a function by name.
   ///
   /// \return null if this module has no such function
-  SILFunction *lookUpFunction(StringRef name) const {
+  SILFunction *lookUpFunction(StringRef name, bool byAsmName = false) const {
+    if (byAsmName)
+      return FunctionByAsmNameTable.lookup(name);
     return FunctionTable.lookup(name);
   }
 

include/swift/Serialization/SerializedSILLoader.h

@@ -62,8 +62,10 @@ class SerializedSILLoader {
 
   SILFunction *lookupSILFunction(SILFunction *Callee, bool onlyUpdateLinkage);
   SILFunction *lookupSILFunction(StringRef Name,
-                                 std::optional<SILLinkage> linkage);
-  SILGlobalVariable *lookupSILGlobalVariable(StringRef Name);
+                                 std::optional<SILLinkage> linkage,
+                                 bool byAsmName = false);
+  SILGlobalVariable *lookupSILGlobalVariable(StringRef Name,
+                                             bool byAsmName = false);
   bool hasSILFunction(StringRef Name,
                       std::optional<SILLinkage> linkage = std::nullopt);
   SILVTable *lookupVTable(const ClassDecl *C);

lib/AST/Attr.cpp

@@ -3273,11 +3273,11 @@ bool MacroRoleAttr::hasNameKind(MacroIntroducedDeclNameKind kind) const {
   }) != getNames().end();
 }
 
-StringRef ExternAttr::getCName(const FuncDecl *D) const {
+StringRef ExternAttr::getCName(const ValueDecl *D) const {
   if (auto cName = this->Name)
     return cName.value();
   // If no name was specified, fall back on the Swift base name without mangling.
-  // Base name is always available and non-empty for FuncDecl.
+  // Base name is always available and non-empty for functions and variables.
   return D->getBaseIdentifier().str();
 }
 

lib/SIL/IR/SILDeclRef.cpp

@@ -1386,18 +1386,6 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
         silConfig);
   }
 
-  // As a special case, Clang functions and globals don't get mangled at all
-  // - except \c objc_direct decls.
-  if (hasDecl() && !isDefaultArgGenerator()) {
-    if (getDecl()->getClangDecl()) {
-      if (!isForeignToNativeThunk() && !isNativeToForeignThunk()) {
-        auto clangMangling = mangleClangDecl(getDecl(), isForeign);
-        if (!clangMangling.empty())
-          return clangMangling;
-      }
-    }
-  }
-
   // Mangle prespecializations.
   if (getSpecializedSignature()) {
     SILDeclRef nonSpecializedDeclRef = *this;
@@ -1443,23 +1431,6 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
         return NameA->Name.str();
       }
 
-    // Use a given cdecl name for native-to-foreign thunks. Don't do this
-    // for functions that only have a C entrypoint.
-    if (getDecl()->getAttrs().hasAttribute<CDeclAttr>() &&
-        !(getDecl()->hasOnlyCEntryPoint() &&
-          !getDecl()->getImplementedObjCDecl())) {
-      if (isNativeToForeignThunk() || isForeign) {
-        // If this is an @implementation @_cdecl, mangle it like the clang
-        // function it implements.
-        if (auto objcInterface = getDecl()->getImplementedObjCDecl()) {
-          auto clangMangling = mangleClangDecl(objcInterface, isForeign);
-          if (!clangMangling.empty())
-            return clangMangling;
-        }
-        return getDecl()->getCDeclName().str();
-      }
-    }
-
     if (SKind == ASTMangler::SymbolKind::DistributedThunk) {
       return mangler.mangleDistributedThunk(cast<FuncDecl>(getDecl()));
     }
@@ -1547,13 +1518,33 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
   llvm_unreachable("bad entity kind!");
 }
 
-std::optional<StringRef> SILDeclRef::getAsmName() const {
-  if (isForeign && isFunc()) {
-    auto func = getFuncDecl();
-    if (auto *EA = ExternAttr::find(func->getAttrs(), ExternKind::C))
-      return EA->getCName(func);
-    if (func->hasOnlyCEntryPoint() && !func->getImplementedObjCDecl())
-      return func->getCDeclName();
+std::optional<std::string> SILDeclRef::getAsmName() const {
+  if (isAutoDiffDerivativeFunction())
+    return std::nullopt;
+
+  if (hasDecl() && !isDefaultArgGenerator() &&
+      (getDecl()->getClangDecl() || getDecl()->getImplementedObjCDecl())) {
+    // If there is a Clang declaration, use its mangled name.
+    if (isNativeToForeignThunk() || isForeign) {
+      auto decl = getDecl();
+      auto hasClangDecl = decl->getClangDecl()
+          ? decl : decl->getImplementedObjCDecl();
+      auto clangMangling = mangleClangDecl(hasClangDecl, isForeign);
+      if (!clangMangling.empty())
+        return clangMangling;
+    }
+  }
+
+  if (isForeign && hasDecl()) {
+    // @_extern(c)
+    auto decl = getDecl();
+    if (auto *EA = ExternAttr::find(decl->getAttrs(), ExternKind::C))
+      if (auto VD = dyn_cast<ValueDecl>(decl))
+        return std::string(EA->getCName(VD));
+
+    // @c/@_cdecl
+    if (decl->getAttrs().hasAttribute<CDeclAttr>())
+      return std::string(decl->getCDeclName());
   }
 
   return std::nullopt;

lib/SIL/IR/SILFunction.cpp

@@ -442,6 +442,16 @@ bool SILFunction::hasForeignBody() const {
   return SILDeclRef::isClangGenerated(getClangNode());
 }
 
+void SILFunction::setAsmName(StringRef value) {
+  assert((AsmName.empty() || value == AsmName) && "Cannot change asmname");
+  AsmName = value;
+
+  if (!value.empty()) {
+    // Update the function-by-asm-name-table.
+    getModule().FunctionByAsmNameTable.insert({AsmName, this});
+  }
+}
+
 const SILFunction *SILFunction::getOriginOfSpecialization() const {
   if (!isSpecialization())
     return nullptr;
@@ -1049,7 +1059,8 @@ bool SILFunction::isSwiftRuntimeFunction(
 }
 
 bool SILFunction::isSwiftRuntimeFunction() const {
-  return isSwiftRuntimeFunction(getName(), getParentModule());
+  return isSwiftRuntimeFunction(asmName(), getParentModule()) ||
+    isSwiftRuntimeFunction(getName(), getParentModule());
 }
 
 bool

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -128,7 +128,7 @@ void SILFunctionBuilder::addFunctionAttributes(
     }
 
     if (auto asmName = constant.getAsmName()) {
-      F->setAsmName(*asmName);
+      F->setAsmName(M.getASTContext().AllocateCopy(*asmName));
     }
   }
 
@@ -177,16 +177,18 @@ void SILFunctionBuilder::addFunctionAttributes(
     if (Attrs.hasAttribute<CDeclAttr>()) {
       // If the function is marked with @c, expose only C compatible
       // thunk function.
-      shouldExportDecl = constant.isNativeToForeignThunk();
+      shouldExportDecl = constant.isNativeToForeignThunk() || constant.isForeign;
     }
     if (EA->getExposureKind() == ExposureKind::Wasm && shouldExportDecl) {
       // A wasm-level exported function must be retained if it appears in a
       // compilation unit.
       F->setMarkedAsUsed(true);
-      if (EA->Name.empty())
-        F->setWasmExportName(F->getName());
-      else
+      if (!EA->Name.empty())
         F->setWasmExportName(EA->Name);
+      else if (!F->asmName().empty())
+        F->setWasmExportName(F->asmName());
+      else
+        F->setWasmExportName(F->getName());
     }
   }