Merge pull request #85203 from DougGregor/clang-decl-asmname

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/AST/DiagnosticsIRGen.def

@@ -117,5 +117,9 @@ NOTE(maybe_missing_parameter, none,
      "%select{constraint|parameter}0",
      (bool, const clang::NamedDecl *))
 
+ERROR(ir_function_redefinition_external,none,
+      "multiple definitions of symbol '%0'",
+      (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

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/ASTMangler.cpp

@@ -669,6 +669,19 @@ void ASTMangler::beginManglingWithAutoDiffOriginalFunction(
     beginManglingClangDecl(typedefType->getDecl());
     return;
   }
+
+  if (auto *EA = ExternAttr::find(afd->getAttrs(), ExternKind::C)) {
+    beginManglingWithoutPrefix();
+    appendOperator(EA->getCName(afd));
+    return;
+  }
+
+  if (afd->getAttrs().hasAttribute<CDeclAttr>()) {
+    beginManglingWithoutPrefix();
+    appendOperator(afd->getCDeclName());
+    return;
+  }
+
   beginMangling();
   if (auto *cd = dyn_cast<ConstructorDecl>(afd))
     appendConstructorEntity(cd, /*isAllocating*/ !cd->isConvenienceInit());

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/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2066,34 +2066,91 @@ clang::CXXMethodDecl *SwiftDeclSynthesizer::synthesizeCXXForwardingMethod(
 
   // Create a new method in the derived class that calls the base method.
   clang::DeclarationName name = method->getNameInfo().getName();
+  std::string newName;
+  llvm::raw_string_ostream os(newName);
+  bool useExistingName = false;
   if (name.isIdentifier()) {
-    std::string newName;
-    llvm::raw_string_ostream os(newName);
     os << (forwardingMethodKind == ForwardingMethodKind::Virtual
                ? "__synthesizedVirtualCall_"
                : "__synthesizedBaseCall_")
        << name.getAsIdentifierInfo()->getName();
-    name = clang::DeclarationName(
-        &ImporterImpl.getClangPreprocessor().getIdentifierTable().get(
-            os.str()));
-  } else if (name.getCXXOverloadedOperator() == clang::OO_Subscript) {
-    name = clang::DeclarationName(
-        &ImporterImpl.getClangPreprocessor().getIdentifierTable().get(
-            (forwardingMethodKind == ForwardingMethodKind::Virtual
+  } else {
+    switch (auto op = name.getCXXOverloadedOperator()) {
+      case clang::OO_Subscript:
+        os << (forwardingMethodKind == ForwardingMethodKind::Virtual
                  ? "__synthesizedVirtualCall_operatorSubscript"
-                 : "__synthesizedBaseCall_operatorSubscript")));
-  } else if (name.getCXXOverloadedOperator() == clang::OO_Star) {
-    name = clang::DeclarationName(
-        &ImporterImpl.getClangPreprocessor().getIdentifierTable().get(
-            (forwardingMethodKind == ForwardingMethodKind::Virtual
+                 : "__synthesizedBaseCall_operatorSubscript");
+        if (forceConstQualifier)
+          os << "C";
+        break;
+
+      case clang::OO_Star:
+        os << (forwardingMethodKind == ForwardingMethodKind::Virtual
                  ? "__synthesizedVirtualCall_operatorStar"
-                 : "__synthesizedBaseCall_operatorStar")));
-  } else if (name.getCXXOverloadedOperator() == clang::OO_Call) {
-    assert(forwardingMethodKind != ForwardingMethodKind::Virtual);
+                 : "__synthesizedBaseCall_operatorStar");
+        if (forceConstQualifier)
+          os << "C";
+        break;
+
+      case clang::OO_Call:
+        assert(forwardingMethodKind != ForwardingMethodKind::Virtual);
+        os << "__synthesizedBaseCall_operatorCall";
+        if (forceConstQualifier)
+          os << "C";
+        break;
+
+      case clang::OO_Plus:
+      case clang::OO_Minus:
+      case clang::OO_Slash:
+      case clang::OO_PlusEqual:
+      case clang::OO_MinusEqual:
+      case clang::OO_StarEqual:
+      case clang::OO_SlashEqual:
+      case clang::OO_Percent:
+      case clang::OO_Caret:
+      case clang::OO_Amp:
+      case clang::OO_Pipe:
+      case clang::OO_Tilde:
+      case clang::OO_Exclaim:
+      case clang::OO_Less:
+      case clang::OO_Greater:
+      case clang::OO_LessLess:
+      case clang::OO_GreaterGreater:
+      case clang::OO_EqualEqual:
+      case clang::OO_PlusPlus:
+      case clang::OO_ExclaimEqual:
+      case clang::OO_LessEqual:
+      case clang::OO_GreaterEqual:
+      case clang::OO_AmpAmp:
+      case clang::OO_PipePipe:
+        os << importer::getOperatorName(ImporterImpl.SwiftContext, op).str();
+        break;
+
+      default:
+        useExistingName = true;
+        break;
+    }
+  }
+
+  if (!useExistingName) {
+    // The created method is inside the derived class already. If that's
+    // different from the base class, also include the base class in the
+    // mangling to keep this separate from other similar functions cloned from
+    // other base classes.
+    if (derivedClass != baseClass) {
+      os << "_";
+      std::unique_ptr<clang::ItaniumMangleContext> mangler{
+          clang::ItaniumMangleContext::create(clangCtx, clangCtx.getDiagnostics())};
+      auto derivedType = clangCtx.getTypeDeclType(baseClass)
+        .getCanonicalType();
+      mangler->mangleCanonicalTypeName(derivedType, os);
+    }
+
     name = clang::DeclarationName(
         &ImporterImpl.getClangPreprocessor().getIdentifierTable().get(
-            "__synthesizedBaseCall_operatorCall"));
+            os.str()));
   }
+
   auto methodType = method->getType();
   // Check if we need to drop the reference from the return type
   // of the new method. This is needed when a synthesized `operator []`