Augment the symbol type classification for dyld trie exports with more detail

[jasonmolenda]

Summary

My patch to augment the symbol table in Mach-O files with the dyld trie exports data structure only categorized symbols as code or data, but Greg Clayton had a patch to do something similar to swift a few years ago that had a more extensive categorization of symbols, as well as extracting some objc class/ivar names from the entries. This patch is basically just Greg's, updated a bit and with a test case added to it.

I'm most interested for any better ideas for a test where I get two symbols by a name search, and want to verify that one symbol has an objc type and the other symbol has a second objc type, it doesn't matter the order of the symbols returned. The test case addition works, but it's not pretty - I was trying to think of a better way to do this but didn't come up with anything in the moment.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

if (childNodeOffset) {
         return false;
       }
     }
     nameSlices.pop_back();
   }
   return true;
 }
 
+static SymbolType GetSymbolType(const char *&symbol_name,
+                                bool &demangled_is_synthesized,
+                                const SectionSP &text_section_sp,
+                                const SectionSP &data_section_sp,
+                                const SectionSP &data_dirty_section_sp,
+                                const SectionSP &data_const_section_sp,
+                                const SectionSP &symbol_section) {
+  SymbolType type = eSymbolTypeInvalid;
+
+  const char *symbol_sect_name = symbol_section->GetName().AsCString();
+  if (symbol_section->IsDescendant(text_section_sp.get())) {
+    if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
+                                S_ATTR_SELF_MODIFYING_CODE |
+                                S_ATTR_SOME_INSTRUCTIONS))
+      type = eSymbolTypeData;
+    else
+      type = eSymbolTypeCode;
+  } else if (symbol_section->IsDescendant(data_section_sp.get()) ||
+             symbol_section->IsDescendant(data_dirty_section_sp.get()) ||
+             symbol_section->IsDescendant(data_const_section_sp.get())) {
+    if (symbol_sect_name &&
+        ::strstr(symbol_sect_name, "__objc") == symbol_sect_name) {
+      type = eSymbolTypeRuntime;
+
+      if (symbol_name) {
+        llvm::StringRef symbol_name_ref(symbol_name);
+        if (symbol_name_ref.startswith("OBJC_")) {
+          static const llvm::StringRef g_objc_v2_prefix_class("OBJC_CLASS_$_");
+          static const llvm::StringRef g_objc_v2_prefix_metaclass(
+              "OBJC_METACLASS_$_");
+          static const llvm::StringRef g_objc_v2_prefix_ivar("OBJC_IVAR_$_");
+          if (symbol_name_ref.startswith(g_objc_v2_prefix_class)) {
+            symbol_name = symbol_name + g_objc_v2_prefix_class.size();
+            type = eSymbolTypeObjCClass;
+            demangled_is_synthesized = true;
+          } else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass)) {
+            symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
+            type = eSymbolTypeObjCMetaClass;
+            demangled_is_synthesized = true;
+          } else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar)) {
+            symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
+            type = eSymbolTypeObjCIVar;
+            demangled_is_synthesized = true;
+          }
+        }
+      }
+    } else if (symbol_sect_name &&
+               ::strstr(symbol_sect_name, "__gcc_except_tab") ==
+                   symbol_sect_name) {
+      type = eSymbolTypeException;
+    } else {
+      type = eSymbolTypeData;
+    }
+  } else if (symbol_sect_name &&
+             ::strstr(symbol_sect_name, "__IMPORT") == symbol_sect_name) {
+    type = eSymbolTypeTrampoline;
+  }
+  return type;
+}
+
 // Read the UUID out of a dyld_shared_cache file on-disk.
 UUID ObjectFileMachO::GetSharedCacheUUID(FileSpec dyld_shared_cache,
                                          const ByteOrder byte_order,
                                          const uint32_t addr_byte_size) {
   UUID dsc_uuid;
   DataBufferSP DscData = MapFileData(
       dyld_shared_cache, sizeof(struct lldb_copy_dyld_cache_header_v1), 0);
   if (!DscData)
for (auto &e : external_sym_trie_entries) {
     if (symbols_added.find(e.entry.address) != symbols_added.end())
       continue;
 
     // Find the section that this trie address is in, use that to annotate
     // symbol type as we add the trie address and name to the symbol table.
     Address symbol_addr;
     if (module_sp->ResolveFileAddress(e.entry.address, symbol_addr)) {
       SectionSP symbol_section(symbol_addr.GetSection());
+      const char *symbol_name = e.entry.name.GetCString();
+      bool demangled_is_synthesized = false;
+      SymbolType type =
+          GetSymbolType(symbol_name, demangled_is_synthesized, text_section_sp,
+                        data_section_sp, data_dirty_section_sp,
+                        data_const_section_sp, symbol_section);
+
+      sym[sym_idx].SetType(type);
       if (symbol_section) {
         sym[sym_idx].SetID(synthetic_sym_id++);
-        sym[sym_idx].GetMangled().SetMangledName(e.entry.name);
-        switch (symbol_section->GetType()) {
-        case eSectionTypeCode:
-          sym[sym_idx].SetType(eSymbolTypeCode);
-          break;
-        case eSectionTypeOther:
-        case eSectionTypeData:
-        case eSectionTypeZeroFill:
-          sym[sym_idx].SetType(eSymbolTypeData);
-          break;
-        default:
-          break;
-        }
-        sym[sym_idx].SetIsSynthetic(false);
+        sym[sym_idx].GetMangled().SetMangledName(ConstString(symbol_name));
+        if (demangled_is_synthesized)
+          sym[sym_idx].SetDemangledNameIsSynthesized(true);
+        sym[sym_idx].SetIsSynthetic(true);
         sym[sym_idx].SetExternal(true);
         sym[sym_idx].GetAddressRef() = symbol_addr;
         symbols_added.insert(symbol_addr.GetFileAddress());
         if (e.entry.flags & TRIE_SYMBOL_IS_THUMB)
           sym[sym_idx].SetFlags(MACHO_NLIST_ARM_SYMBOL_IS_THUMB);
         ++sym_idx;
       }
     }

lldb/test/API/macosx/dyld-trie-symbols/Makefile

-CXX_SOURCES := main.cpp
+OBJCXX_SOURCES := main.mm
 EXE := a.out
 MAKE_DSYM := NO
-LD_EXTRAS = -dynamiclib -image_base 0x8000
+LD_EXTRAS = -dynamiclib -image_base 0x8000 -framework Foundation
 CFLAGS = $(CFLAGS_NO_DEBUG)
 
 include Makefile.rules
 
 all: a.out a.out-stripped
 
 a.out-stripped:
   cp a.out a.out-stripped
-  strip a.out-stripped
+  strip -N a.out-stripped

lldb/test/API/macosx/dyld-trie-symbols/TestDyldTrieSymbols.py

def test_dyld_trie_symbols(self):
         stripped_patint_symbols = stripped_target.FindSymbols("pat(int)")
         self.assertEqual(stripped_patint_symbols.GetSize(), 1)
 
         # bar should have been strippped.  We should not find it, or the
         # stripping went wrong.
         stripped_bar_symbols = stripped_target.FindSymbols("bar")
         self.assertEqual(stripped_bar_symbols.GetSize(), 0)
 
+        # confirm that we classified objc runtime symbols correctly and
+        # stripped off the objc prefix from the symbol names.
+        syms_ctx = stripped_target.FindSymbols("SourceBase")
+        self.assertEqual(syms_ctx.GetSize(), 2)
+        sym1 = syms_ctx.GetContextAtIndex(0).GetSymbol()
+        sym2 = syms_ctx.GetContextAtIndex(1).GetSymbol()
+
+        # one of these should be a lldb.eSymbolTypeObjCClass, the other
+        # should be lldb.eSymbolTypeObjCMetaClass.
+        if sym1.GetType() == lldb.eSymbolTypeObjCMetaClass:
+            self.assertEqual(sym2.GetType(), lldb.eSymbolTypeObjCClass)
+        else:
+            if sym1.GetType() == lldb.eSymbolTypeObjCClass:
+                self.assertEqual(sym2.GetType(), lldb.eSymbolTypeObjCMetaClass)
+            else:
+                self.assertTrue(sym1.GetType() == lldb.eSymbolTypeObjCMetaClass or sym1.GetType() == lldb.eSymbolTypeObjCClass)
+
+        syms_ctx = stripped_target.FindSymbols("SourceDerived._derivedValue")
+        self.assertEqual(syms_ctx.GetSize(), 1)
+        sym = syms_ctx.GetContextAtIndex(0).GetSymbol()
+        self.assertEqual(sym.GetType(), lldb.eSymbolTypeObjCIVar)

lldb/test/API/macosx/dyld-trie-symbols/main.cpp

-int patval;          // external symbol, will not be completely stripped
-int pat(int in) {    // external symbol, will not be completely stripped
-  if (patval == 0)
-    patval = in;
-  return patval;
-}
-
-static int fooval;  // static symbol, stripped
-int foo() {         // external symbol, will not be completely stripped
-  if (fooval == 0)
-    fooval = 5;
-  return fooval;
-}
-
-int bazval = 10;   // external symbol, will not be completely stripped
-int baz () {       // external symbol, will not be completely stripped
-  return foo() + bazval;
-}
-
-static int barval = 15; // static symbol, stripped
-static int bar () {     // static symbol, stripped; __lldb_unnamed_symbol from func starts
-  return baz() + barval;
-}
-
-int calculate ()   // external symbol, will not be completely stripped
-{
-  return bar();
-}
-

lldb/test/API/macosx/dyld-trie-symbols/main.mm

+#import <Foundation/Foundation.h>
+
+// SourceBase will be the base class of Source.  We'll pass a Source object into a
+// function as a SourceBase, and then see if the dynamic typing can get us through the KVO
+// goo and all the way back to Source.
+
+@interface SourceBase: NSObject
+{
+    uint32_t _value;
+}
+- (SourceBase *) init;
+- (uint32_t) getValue;
+@end
+
+@implementation SourceBase
+- (SourceBase *) init
+{
+    [super init];
+    _value = 10;
+    return self;
+}
+- (uint32_t) getValue
+{
+    return _value;
+}
+@end
+
+// Source is a class that will be observed by the Observer class below.
+// When Observer sets itself up to observe this property (in initWithASource)
+// the KVO system will overwrite the "isa" pointer of the object with the "kvo'ed" 
+// one.
+
+@interface Source : SourceBase
+{
+    int _property;
+}
+- (Source *) init;
+- (void) setProperty: (int) newValue;
+@end
+
+@implementation Source
+- (Source *) init
+{
+    [super init];
+    _property = 20;
+    return self;
+}
+- (void) setProperty: (int) newValue
+{
+    _property = newValue;  // This is the line in setProperty, make sure we step to here.
+}
+@end
+
+@interface SourceDerived : Source
+{
+    int _derivedValue;
+}
+- (SourceDerived *) init;
+- (uint32_t) getValue;
+@end
+
+@implementation SourceDerived
+- (SourceDerived *) init
+{
+    [super init];
+    _derivedValue = 30;
+    return self;
+}
+- (uint32_t) getValue
+{
+    return _derivedValue;
+}
+@end
+
+// Observer is the object that will watch Source and cause KVO to swizzle it...
+
+@interface Observer : NSObject
+{
+    Source *_source;
+}
++ (Observer *) observerWithSource: (Source *) source;
+- (Observer *) initWithASource: (Source *) source;
+- (void) observeValueForKeyPath: (NSString *) path 
+           ofObject: (id) object
+       change: (NSDictionary *) change
+      context: (void *) context;
+@end
+
+@implementation Observer
+
++ (Observer *) observerWithSource: (Source *) inSource;
+{
+    Observer *retval;
+
+    retval = [[Observer alloc] initWithASource: inSource];
+    return retval;
+}
+
+- (Observer *) initWithASource: (Source *) source
+{
+    [super init];
+    _source = source;
+    [_source addObserver: self 
+      forKeyPath: @"property" 
+      options: (NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld)
+      context: NULL];
+    return self;
+}
+
+- (void) observeValueForKeyPath: (NSString *) path 
+           ofObject: (id) object
+       change: (NSDictionary *) change
+      context: (void *) context
+{
+    printf ("Observer function called.\n");
+    return;
+}
+@end
+
+
+int patval;          // external symbol, will not be completely stripped
+int pat(int in) {    // external symbol, will not be completely stripped
+  if (patval == 0)
+    patval = in;
+  return patval;
+}
+
+static int fooval;  // static symbol, stripped
+int foo() {         // external symbol, will not be completely stripped
+  if (fooval == 0)
+    fooval = 5;
+  return fooval;
+}
+
+int bazval = 10;   // external symbol, will not be completely stripped
+int baz () {       // external symbol, will not be completely stripped
+  return foo() + bazval;
+}
+
+static int barval = 15; // static symbol, stripped
+static int bar () {     // static symbol, stripped; __lldb_unnamed_symbol from func starts
+  return baz() + barval;
+}
+
+int calculate ()   // external symbol, will not be completely stripped
+{
+  return bar();
+}
+