[index] Generate class & metaclass manglings for objc

[kastiglione]

Summary

ObjC classes have two associated symbols, one for the class and one for the
metaclass.

This change overloads CodegenNameGenerator::getAllManglings to produce both
class and metaclass symbols.

While this function is called by clang_Cursor_getCXXManglings, it's only
called for CXXRecordDecl and CXXMethodDecl, and so libclang's behavior is
unchanged.

[kastiglione]

Fix string type conversion

[alexander-shaposhnikov]

lib/Index/CodegenNameGenerator.cpp

80 ↗

(On Diff #114527)

this lambda returns a StringRef constructed from a SmallString variable (on stack) => StringRef outlives the owning variable - looks like a bug

[alexander-shaposhnikov]

to me this looks reasonable, although i'm probably not qualified to sign off, so i would wait for @abdulras and @arphaman.
The only comment i have on my mind - it would be good to add a test.

[kastiglione]

lib/Index/CodegenNameGenerator.cpp

80 ↗

(On Diff #114527)

thanks, I ran into this. I fixed it in an update.

[kastiglione]

lib/Index/CodegenNameGenerator.cpp

80 ↗

(On Diff #114527)

The SmallString is converted to a StringRef with .str(), and then that StringRef is implicitly converted to a std::string which of course allocates memory.

[alexander-shaposhnikov]

lib/Index/CodegenNameGenerator.cpp

80 ↗

(On Diff #114527)

yeah, my comment was referring to the very first revision, now this looks correct

[kastiglione]

For testing, I'm looking for suggestions. For test/Index, the tests use the c-index-test binary, which uses libclang, which in turn uses this file. However as mentioned in the description, this new functionality isn't exposed by libclang and so in turn isn't exposed by c-index-test. One way to solve this is to add a new function to libclang (clang_Cursor_getObjCManglings) but is that polluting an API when nobody is actually asking for that function?

lib/Index/CodegenNameGenerator.cpp

80 ↗

(On Diff #114527)

thanks for catching it!

[arphaman]

You should be able to test it using a unittest if this is not exposed in the C API.

[compnerd]

lib/Index/CodegenNameGenerator.cpp

77–78 ↗

(On Diff #114528)

I think it could be nicer to split this into a separate check:

if (ClassName.empty())
  return {};

87–88 ↗

(On Diff #114528)

This isn't correct. This works for the macosx, macosx-fragile, ios, and watchos runtimes. However, it is incorrect for gcc, gnustep, and objfw. The latter use _OBJC_CLASS_ and _OBJC_METACLASS_ as the prefixes. Please consult the value for -fobjc-runtime when constructing the mangling.

[kastiglione]

Handle GNU symbols

[compnerd]

Please add tests for the mangling.

lib/Index/CodegenNameGenerator.cpp

176 ↗

(On Diff #114863)

No need for the else.

[kastiglione]

Add tests via c-index-test/libclang

cfe/trunk/include/clang-c/Index.h

 
 /**
  * \brief Retrieve the CXStrings representing the mangled symbols of the C++
  * constructor or destructor at the cursor.
  */
 CINDEX_LINKAGE CXStringSet *clang_Cursor_getCXXManglings(CXCursor);
 
 /**
+ * \brief Retrieve the CXStrings representing the mangled symbols of the ObjC
+ * class interface or implementation at the cursor.
+ */
+CINDEX_LINKAGE CXStringSet *clang_Cursor_getObjCManglings(CXCursor);
+
+/**
  * @}
  */
 
 /**
  * \defgroup CINDEX_MODULE Module introspection
  *
  * The functions in this group provide access to information about modules.
  *

cfe/trunk/lib/Index/CodegenNameGenerator.cpp

std::string getName(const Decl *D) {
     std::string Name;
     {
       llvm::raw_string_ostream OS(Name);
       writeName(D, OS);
     }
     return Name;
   }
 
+  enum ObjCKind {
+    ObjCClass,
+    ObjCMetaclass,
+  };
+
+  std::vector<std::string> getAllManglings(const ObjCContainerDecl *OCD) {
+    StringRef ClassName;
+    if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
+      ClassName = OID->getObjCRuntimeNameAsString();
+    else if (const auto *OID = dyn_cast<ObjCImplementationDecl>(OCD))
+      ClassName = OID->getObjCRuntimeNameAsString();
+
+    if (ClassName.empty())
+      return {};
+
+    auto Mangle = [&](ObjCKind Kind, StringRef ClassName) -> std::string {
+      SmallString<40> Mangled;
+      auto Prefix = getClassSymbolPrefix(Kind, OCD->getASTContext());
+      llvm::Mangler::getNameWithPrefix(Mangled, Prefix + ClassName, DL);
+      return Mangled.str();
+    };
+
+    return {
+      Mangle(ObjCClass, ClassName),
+      Mangle(ObjCMetaclass, ClassName),
+    };
+  }
+
   std::vector<std::string> getAllManglings(const Decl *D) {
+    if (const auto *OCD = dyn_cast<ObjCContainerDecl>(D))
+      return getAllManglings(OCD);
+
     if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
       return {};
 
     const NamedDecl *ND = cast<NamedDecl>(D);
 
     ASTContext &Ctx = ND->getASTContext();
     std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
 
if (MC->shouldMangleDeclName(D)) {
       if (!II)
         return true;
       OS << II->getName();
       return false;
     }
   }
 
   void writeObjCClassName(const ObjCInterfaceDecl *D, raw_ostream &OS) {
-    OS << getClassSymbolPrefix();
+    OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
     OS << D->getObjCRuntimeNameAsString();
   }
 
-  static StringRef getClassSymbolPrefix() {
-    return "OBJC_CLASS_$_";
+  static StringRef getClassSymbolPrefix(ObjCKind Kind, const ASTContext &Context) {
+    if (Context.getLangOpts().ObjCRuntime.isGNUFamily())
+      return Kind == ObjCMetaclass ? "_OBJC_METACLASS_" : "_OBJC_CLASS_";
+    return Kind == ObjCMetaclass ? "OBJC_METACLASS_$_" : "OBJC_CLASS_$_";
   }
 
   std::string getMangledStructor(const NamedDecl *ND, unsigned StructorType) {
     std::string FrontendBuf;
     llvm::raw_string_ostream FOS(FrontendBuf);
 
     if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
       MC->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);

cfe/trunk/test/Index/print-objc-manglings.m

+// RUN: c-index-test -write-pch %t.macho.ast -target i686-apple-darwin %s
+// RUN: c-index-test -test-print-manglings %t.macho.ast | FileCheck --check-prefix=MACHO %s
+
+// RUN: c-index-test -write-pch %t.itanium.ast -target i686-pc-linux-gnu %s
+// RUN: c-index-test -test-print-manglings %t.itanium.ast | FileCheck --check-prefix=ITANIUM %s
+
+@interface C
+@end
+
+// MACHO: ObjCInterfaceDecl=C{{.*}} [mangled=_OBJC_CLASS_$_C] [mangled=_OBJC_METACLASS_$_C]
+// ITANIUM: ObjCInterfaceDecl=C{{.*}} [mangled=_OBJC_CLASS_C] [mangled=_OBJC_METACLASS_C]
+
+@implementation C
+@end
+
+// MACHO: ObjCImplementationDecl=C{{.*}} (Definition) [mangled=_OBJC_CLASS_$_C] [mangled=_OBJC_METACLASS_$_C]
+// ITANIUM: ObjCImplementationDecl=C{{.*}} (Definition) [mangled=_OBJC_CLASS_C] [mangled=_OBJC_METACLASS_C]
+

cfe/trunk/tools/c-index-test/c-index-test.c

static enum CXChildVisitResult PrintManglings(CXCursor cursor, CXCursor p,
   if (clang_isUnexposed(clang_getCursorKind(cursor)))
     return CXChildVisit_Recurse;
   if (!clang_isDeclaration(clang_getCursorKind(cursor)))
     return CXChildVisit_Recurse;
   if (clang_getCursorKind(cursor) == CXCursor_ParmDecl)
     return CXChildVisit_Continue;
   PrintCursor(cursor, NULL);
   Manglings = clang_Cursor_getCXXManglings(cursor);
+  if (Manglings) {
     for (I = 0, E = Manglings->Count; I < E; ++I)
       printf(" [mangled=%s]", clang_getCString(Manglings->Strings[I]));
     clang_disposeStringSet(Manglings);
     printf("\n");
+  }
+  Manglings = clang_Cursor_getObjCManglings(cursor);
+  if (Manglings) {
+    for (I = 0, E = Manglings->Count; I < E; ++I)
+      printf(" [mangled=%s]", clang_getCString(Manglings->Strings[I]));
+    clang_disposeStringSet(Manglings);
+    printf("\n");
+  }
   return CXChildVisit_Recurse;
 }
 
 /******************************************************************************/
 /* Bitwidth testing.                                                          */
 /******************************************************************************/
 
 static enum CXChildVisitResult PrintBitWidth(CXCursor cursor, CXCursor p,

cfe/trunk/tools/libclang/CIndex.cpp

if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
     return nullptr;
 
   ASTContext &Ctx = D->getASTContext();
   index::CodegenNameGenerator CGNameGen(Ctx);
   std::vector<std::string> Manglings = CGNameGen.getAllManglings(D);
   return cxstring::createSet(Manglings);
 }
 
+CXStringSet *clang_Cursor_getObjCManglings(CXCursor C) {
+  if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
+    return nullptr;
+
+  const Decl *D = getCursorDecl(C);
+  if (!(isa<ObjCInterfaceDecl>(D) || isa<ObjCImplementationDecl>(D)))
+    return nullptr;
+
+  ASTContext &Ctx = D->getASTContext();
+  index::CodegenNameGenerator CGNameGen(Ctx);
+  std::vector<std::string> Manglings = CGNameGen.getAllManglings(D);
+  return cxstring::createSet(Manglings);
+}
+
 CXString clang_getCursorDisplayName(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return clang_getCursorSpelling(C);
   
   const Decl *D = getCursorDecl(C);
   if (!D)
     return cxstring::createEmpty();
 

cfe/trunk/tools/libclang/libclang.exports

 clang_Cursor_getTemplateArgumentKind
 clang_Cursor_getTemplateArgumentType
 clang_Cursor_getTemplateArgumentValue
 clang_Cursor_getTemplateArgumentUnsignedValue
 clang_Cursor_getBriefCommentText
 clang_Cursor_getCommentRange
 clang_Cursor_getCXXManglings
 clang_Cursor_getMangling
+clang_Cursor_getObjCManglings
 clang_Cursor_getParsedComment
 clang_Cursor_getRawCommentText
 clang_Cursor_getNumArguments
 clang_Cursor_getObjCDeclQualifiers
 clang_Cursor_getObjCPropertyAttributes
 clang_Cursor_getObjCSelectorIndex
 clang_Cursor_getOffsetOfField
 clang_Cursor_getSpellingNameRange