Make the expression parser work for missing weak symbols

[jingham]

Summary

lldb wasn't handling weak symbols, so if you were debugging a binary that used a weak symbol, and the symbol was missing, any references to the symbol would result in a symbol not found error. But it is actually legitimate to refer to missing weak symbols, you just have to test them against NULL first.

This patch does three things:

1. Adds a bit to indicate weakness to Symbol and IsWeak & SetIsWeak accessors
2. Teaches the ObjectFileMachO to detect weak symbols and mark them appropriately
3. Gets the symbol -> address lookup in IRExecutionUnit.cpp to mark missing weak symbols as such.

[clayborg]

A few nits, but nothing structural. Fix those and this will be good to go.

include/lldb/Symbol/Symbol.h

257 ↗

(On Diff #206975)

This will increase the size of Symbol since this extra bit makes it go over 16 bits in size. We can steal a bit away from m_type since it is used to hold lldb::SymbolType and we only have 28 lldb::SymbolType enums. You might need to check that the Swift branch didn't add any.

258 ↗

(On Diff #206975)

change to:

m_type : 6;

See above comment.

packages/Python/lldbsuite/test/expression_command/weak_symbols/TestWeakSymbols.py

24 ↗

(On Diff #206975)

We should get ELF support for this as well once this is in.

source/Expression/IRInterpreter.cpp

236 ↗

(On Diff #206975)

Init this to something in case function below gets changed and doesn't init it.

source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

436 ↗

(On Diff #206975)

init to something.

862 ↗

(On Diff #206975)

init to something

1034 ↗

(On Diff #206975)

init to something.

[jingham]

Addressed Greg's comments

[jingham]

include/lldb/Symbol/Symbol.h

258 ↗

(On Diff #206975)

Yup, apparently I can't count... Anyway, swift did add a few but we're still well under 6 bits. I added a comment here saying where m_type gets its values from and in the enum saying it needs to stay under 6 bits.

packages/Python/lldbsuite/test/expression_command/weak_symbols/TestWeakSymbols.py

24 ↗

(On Diff #206975)

I don't know how this works in ELF, but if somebody else wants to try their hand at it, that would be great.

lldb/trunk/include/lldb/Expression/IRExecutionUnit.h

public:
 
   void PopulateSectionList(lldb_private::ObjectFile *obj_file,
                            lldb_private::SectionList &section_list) override;
 
   ArchSpec GetArchitecture() override;
 
   lldb::ModuleSP GetJITModule();
 
-  lldb::addr_t FindSymbol(ConstString name);
+  lldb::addr_t FindSymbol(ConstString name, bool &missing_weak);
 
   void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
 
   /// \class JittedFunction IRExecutionUnit.h
   /// "lldb/Expression/IRExecutionUnit.h"
   /// Encapsulates a single function that has been generated by the JIT.
   ///
   /// Functions that have been generated by the JIT are first resident in the
private:
   void CollectCandidateCPlusPlusNames(std::vector<SearchSpec> &CPP_specs,
                                       const std::vector<SearchSpec> &C_specs,
                                       const SymbolContext &sc);
 
   void CollectFallbackNames(std::vector<SearchSpec> &fallback_specs,
                             const std::vector<SearchSpec> &C_specs);
 
   lldb::addr_t FindInSymbols(const std::vector<SearchSpec> &specs,
-                             const lldb_private::SymbolContext &sc);
+                             const lldb_private::SymbolContext &sc,
+                             bool &symbol_was_missing_weak);
 
   lldb::addr_t FindInRuntimes(const std::vector<SearchSpec> &specs,
                               const lldb_private::SymbolContext &sc);
 
   lldb::addr_t FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs,
                                         const lldb_private::SymbolContext &sc);
 
   void ReportSymbolLookupError(ConstString name);
bool finalizeMemory(std::string *ErrMsg) override {
       //   llvm::SectionMemoryManager
       return false;
     }
 
     void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
                           size_t Size) override {}
 
     uint64_t getSymbolAddress(const std::string &Name) override;
     
+    // Find the address of the symbol Name.  If Name is a missing weak symbol
+    // then missing_weak will be true.
+    uint64_t GetSymbolAddressAndPresence(const std::string &Name, 
+                                         bool &missing_weak);
+    
+    llvm::JITSymbol findSymbol(const std::string &Name) override;
+
     void *getPointerToNamedFunction(const std::string &Name,
                                     bool AbortOnFailure = true) override;
 
   private:
     std::unique_ptr<SectionMemoryManager> m_default_mm_up; ///< The memory
                                                            /// allocator to use
                                                            /// in actually
                                                            /// creating space.

lldb/trunk/include/lldb/Symbol/Symbol.h

public:
 
   bool IsExternal() const { return m_is_external; }
 
   void SetExternal(bool b) { m_is_external = b; }
 
   bool IsTrampoline() const;
 
   bool IsIndirect() const;
   
+  bool IsWeak() const { return m_is_weak; }
+  
+  void SetIsWeak (bool b) { m_is_weak = b; }
+
   bool GetByteSizeIsValid() const { return m_size_is_valid; }
 
   lldb::addr_t GetByteSize() const;
 
   void SetByteSize(lldb::addr_t size) {
     m_size_is_valid = size > 0;
     m_addr_range.SetByteSize(size);
   }
uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
                                  // symbol and the next
       m_size_is_valid : 1,
       m_demangled_is_synthesized : 1, // The demangled name was created should
                                       // not be used for expressions or other
                                       // lookups
       m_contains_linker_annotations : 1, // The symbol name contains linker
                                          // annotations, which are optional when
                                          // doing name lookups
-      m_type : 7;
+      m_is_weak : 1,
+      m_type : 6;            // Values from the lldb::SymbolType enum.
   Mangled m_mangled;         // uniqued symbol name/mangled name pair
   AddressRange m_addr_range; // Contains the value, or the section offset
                              // address when the value is an address in a
                              // section, and the size (if any)
   uint32_t m_flags; // A copy of the flags from the original symbol table, the
                     // ObjectFile plug-in can interpret these
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Symbol_h_

lldb/trunk/include/lldb/lldb-enumerations.h

enum CommandArgumentType {
   eArgTypeWatchType,
   eArgRawInput,
   eArgTypeCommand,
   eArgTypeLastArg // Always keep this entry as the last entry in this
                   // enumeration!!
 };
 
 // Symbol types
+// Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63 
+// entries you will have to resize that field.
 enum SymbolType {
   eSymbolTypeAny = 0,
   eSymbolTypeInvalid = 0,
   eSymbolTypeAbsolute,
   eSymbolTypeCode,
   eSymbolTypeResolver,
   eSymbolTypeData,
   eSymbolTypeTrampoline,

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/Makefile

+LEVEL = ../../make
+CFLAGS_EXTRAS += -std=c99
+LD_FLAGS := -dynamiclib
+include $(LEVEL)/Makefile.rules
+
+all: a.out dylib missing
+
+dylib: dylib.o
+  $(CC)  $(LD_FLAGS) -o libdylib.dylib dylib.o
+
+missing: dylib2.o
+  mkdir hidden
+  $(CC)  $(LD_FLAGS) -o hidden/libdylib.dylib dylib2.o
+
+a.out: main.o dylib missing
+  $(CC)  $(CFLAGS) -L. -ldylib main.o
+
+dylib.o: dylib.h $(SRCDIR)/dylib.c
+  $(CC) -DHAS_THEM  $(CFLAGS) -c $(SRCDIR)/dylib.c
+
+dylib2.o: dylib.h $(SRCDIR)/dylib.c
+  $(CC)  $(CFLAGS) -c $(SRCDIR)/dylib.c -o dylib2.o
+
+main.o: dylib.h $(SRCDIR)/main.c
+  $(CC)  $(CFLAGS) -c $(SRCDIR)/main.c -fmodules
+

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/TestWeakSymbols.py

+"""
+Test that we can compile expressions referring to
+absent weak symbols from a dylib.
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+from lldbsuite.test import decorators
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+
+class TestWeakSymbolsInExpressions(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @decorators.skipUnlessDarwin
+    def test_weak_symbol_in_expr(self):
+        """Tests that we can refer to weak symbols in expressions."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.do_test()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def run_weak_var_check (self, weak_varname, present):
+        # The expression will modify present_weak_int to signify which branch
+        # was taken.  Set it to so we don't get confused by a previous run.
+        value = self.target.FindFirstGlobalVariable("present_weak_int")
+        value.SetValueFromCString("0")
+        if present:
+            correct_value = 10
+        else:
+            correct_value = 20
+            
+        # Note, I'm adding the "; 10" at the end of the expression to work around
+        # the bug that expressions with no result currently return False for Success()...
+        expr = "if (&" + weak_varname + " != NULL) { present_weak_int = 10; } else { present_weak_int = 20;}; 10"
+        result = self.frame.EvaluateExpression(expr)
+        self.assertTrue(result.GetError().Success(), "absent_weak_int expr failed: %s"%(result.GetError().GetCString()))
+        self.assertEqual(value.GetValueAsSigned(), correct_value, "Didn't change present_weak_int correctly.")
+        
+    def do_test(self):
+        hidden_dir = os.path.join(self.getBuildDir(), "hidden")
+        
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetWorkingDirectory(self.getBuildDir())
+        # We have to point to the hidden directory to pick up the
+        # version of the dylib without the weak symbols:
+        env_expr = self.platformContext.shlib_environment_var + "=" + hidden_dir
+        launch_info.SetEnvironmentEntries([env_expr], True)
+        
+        (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                                                            "Set a breakpoint here", self.main_source_file,
+                                                                            launch_info = launch_info)
+        # First we have to import the Dylib module so we get the type info
+        # for the weak symbol.  We need to add the source dir to the module
+        # search paths, and then run @import to introduce it into the expression
+        # context:
+        self.dbg.HandleCommand("settings set target.clang-module-search-paths " + self.getSourceDir())
+        
+        self.frame = thread.frames[0]
+        self.assertTrue(self.frame.IsValid(), "Got a good frame")
+        options = lldb.SBExpressionOptions()
+        options.SetLanguage(lldb.eLanguageTypeObjC)
+        result = self.frame.EvaluateExpression("@import Dylib", options)
+
+        # Now run an expression that references an absent weak symbol:
+        self.run_weak_var_check("absent_weak_int", False)
+        self.run_weak_var_check("absent_weak_function", False)
+        
+        # Make sure we can do the same thing with present weak symbols
+        self.run_weak_var_check("present_weak_int", True)
+        self.run_weak_var_check("present_weak_function", True)

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/dylib.h

+extern int absent_weak_int __attribute__((weak_import));
+
+extern int present_weak_int __attribute__((weak_import));
+
+extern int absent_weak_function() __attribute__((weak_import));
+
+extern int present_weak_function() __attribute__((weak_import));
+

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/dylib.c

+#include "dylib.h"
+
+int present_weak_int = 10;
+int present_weak_function()
+{
+  return present_weak_int;
+}
+
+#if defined HAS_THEM
+int absent_weak_int = 10;
+int absent_weak_function() {
+  return absent_weak_int;
+}
+#endif

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/main.c

+#include "dylib.h"
+#include <stdio.h>
+
+int
+doSomething()
+{
+  // Set a breakpoint here.
+  if (&absent_weak_int != NULL)
+    printf("In absent_weak_int: %d\n", absent_weak_int);
+  if (absent_weak_function != NULL)
+    printf("In absent_weak_func: %p\n", absent_weak_function);
+  if (&present_weak_int != NULL)
+    printf("In present_weak_int: %d\n", present_weak_int);
+  if (present_weak_function != NULL)
+    printf("In present_weak_func: %p\n", present_weak_function);
+
+}
+
+int
+main()
+{
+  return doSomething();
+}

lldb/trunk/packages/Python/lldbsuite/test/expression_command/weak_symbols/module.modulemap

+module Dylib {
+  header "dylib.h"
+}

lldb/trunk/source/Expression/IRExecutionUnit.cpp

if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
         }
       }
     }
   }
 }
 
 lldb::addr_t IRExecutionUnit::FindInSymbols(
     const std::vector<IRExecutionUnit::SearchSpec> &specs,
-    const lldb_private::SymbolContext &sc) {
+    const lldb_private::SymbolContext &sc,
+    bool &symbol_was_missing_weak) {
+  symbol_was_missing_weak = false;
   Target *target = sc.target_sp.get();
 
   if (!target) {
     // we shouldn't be doing any symbol lookup at all without a target
     return LLDB_INVALID_ADDRESS;
   }
 
   for (const SearchSpec &spec : specs) {
     SymbolContextList sc_list;
 
     lldb::addr_t best_internal_load_address = LLDB_INVALID_ADDRESS;
 
     std::function<bool(lldb::addr_t &, SymbolContextList &,
                        const lldb_private::SymbolContext &)>
         get_external_load_address = [&best_internal_load_address, target](
             lldb::addr_t &load_address, SymbolContextList &sc_list,
             const lldb_private::SymbolContext &sc) -> lldb::addr_t {
       load_address = LLDB_INVALID_ADDRESS;
 
-      for (size_t si = 0, se = sc_list.GetSize(); si < se; ++si) {
-        SymbolContext candidate_sc;
+      if (sc_list.GetSize() == 0)
+        return false;
 
-        sc_list.GetContextAtIndex(si, candidate_sc);
+      // missing_weak_symbol will be true only if we found only weak undefined 
+      // references to this symbol.
+      bool symbol_was_missing_weak = true;      
+      for (auto candidate_sc : sc_list.SymbolContexts()) {        
+        // Only symbols can be weak undefined:
+        if (!candidate_sc.symbol)
+          symbol_was_missing_weak = false;
+        else if (candidate_sc.symbol->GetType() != lldb::eSymbolTypeUndefined
+                  || !candidate_sc.symbol->IsWeak())
+          symbol_was_missing_weak = false;
         
         const bool is_external =
             (candidate_sc.function) ||
             (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
         if (candidate_sc.symbol) {
           load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
 
           if (load_address == LLDB_INVALID_ADDRESS) {
             if (target->GetProcessSP())
std::function<bool(lldb::addr_t &, SymbolContextList &,
             return true;
           } else if (best_internal_load_address == LLDB_INVALID_ADDRESS) {
             best_internal_load_address = load_address;
             load_address = LLDB_INVALID_ADDRESS;
           }
         }
       }
 
+      // You test the address of a weak symbol against NULL to see if it is
+      // present.  So we should return 0 for a missing weak symbol.
+      if (symbol_was_missing_weak) {
+        load_address = 0;
+        return true;
+      }
+      
       return false;
     };
 
     if (sc.module_sp) {
       sc.module_sp->FindFunctions(spec.name, nullptr, spec.mask,
                                   true,  // include_symbols
                                   false, // include_inlines
                                   true,  // append
for (const SearchSpec &spec : specs) {
     if (symbol_load_addr != LLDB_INVALID_ADDRESS)
       return symbol_load_addr;
   }
 
   return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t
-IRExecutionUnit::FindSymbol(lldb_private::ConstString name) {
+IRExecutionUnit::FindSymbol(lldb_private::ConstString name, bool &missing_weak) {
   std::vector<SearchSpec> candidate_C_names;
   std::vector<SearchSpec> candidate_CPlusPlus_names;
 
   CollectCandidateCNames(candidate_C_names, name);
   
-  lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx);
-  if (ret == LLDB_INVALID_ADDRESS)
-    ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
+  lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx, missing_weak);
+  if (ret != LLDB_INVALID_ADDRESS)
+    return ret;
+  
+  // If we find the symbol in runtimes or user defined symbols it can't be 
+  // a missing weak symbol.
+  missing_weak = false;
+  if (ret != LLDB_INVALID_ADDRESS)
+    return ret;
 
-  if (ret == LLDB_INVALID_ADDRESS)
-    ret = FindInUserDefinedSymbols(candidate_C_names, m_sym_ctx);
+  if (ret != LLDB_INVALID_ADDRESS)
+    return ret;
 
-  if (ret == LLDB_INVALID_ADDRESS) {
-    CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names,
-                                   m_sym_ctx);
-    ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx);
-  }
+  ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx, missing_weak);
+  if (ret != LLDB_INVALID_ADDRESS)
+    return ret;
 
-  if (ret == LLDB_INVALID_ADDRESS) {
-    std::vector<SearchSpec> candidate_fallback_names;
 
-    CollectFallbackNames(candidate_fallback_names, candidate_C_names);
-    ret = FindInSymbols(candidate_fallback_names, m_sym_ctx);
-  }
+  ret = FindInSymbols(candidate_fallback_names, m_sym_ctx, missing_weak);
 
   return ret;
 }
 
 void IRExecutionUnit::GetStaticInitializers(
     std::vector<lldb::addr_t> &static_initializers) {
   if (llvm::GlobalVariable *global_ctors =
           m_module->getNamedGlobal("llvm.global_ctors")) {
if (llvm::ConstantArray *ctor_array = llvm::dyn_cast<llvm::ConstantArray>(
             }
           }
         }
       }
     }
   }
 }
 
+llvm::JITSymbol 
+IRExecutionUnit::MemoryManager::findSymbol(const std::string &Name) {
+    bool missing_weak = false;
+    uint64_t addr = GetSymbolAddressAndPresence(Name, missing_weak);
+    // This is a weak symbol:
+    if (missing_weak) 
+      return llvm::JITSymbol(addr, 
+          llvm::JITSymbolFlags::Exported | llvm::JITSymbolFlags::Weak);
+    else
+      return llvm::JITSymbol(addr, llvm::JITSymbolFlags::Exported);
+}
+
 uint64_t
 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name) {
+  bool missing_weak = false;
+  return GetSymbolAddressAndPresence(Name, missing_weak);
+}
+
+uint64_t 
+IRExecutionUnit::MemoryManager::GetSymbolAddressAndPresence(
+    const std::string &Name, bool &missing_weak) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   ConstString name_cs(Name.c_str());
 
-  lldb::addr_t ret = m_parent.FindSymbol(name_cs);
+  lldb::addr_t ret = m_parent.FindSymbol(name_cs, missing_weak);
 
   if (ret == LLDB_INVALID_ADDRESS) {
     if (log)
       log->Printf(
           "IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
           Name.c_str());
 
     m_parent.ReportSymbolLookupError(name_cs);

lldb/trunk/source/Expression/IRInterpreter.cpp

public:
 
   bool ResolveConstantValue(APInt &value, const Constant *constant) {
     switch (constant->getValueID()) {
     default:
       break;
     case Value::FunctionVal:
       if (const Function *constant_func = dyn_cast<Function>(constant)) {
         lldb_private::ConstString name(constant_func->getName());
-        lldb::addr_t addr = m_execution_unit.FindSymbol(name);
-        if (addr == LLDB_INVALID_ADDRESS)
+        bool missing_weak = false;
+        lldb::addr_t addr = m_execution_unit.FindSymbol(name, missing_weak);
+        if (addr == LLDB_INVALID_ADDRESS || missing_weak)
           return false;
         value = APInt(m_target_data.getPointerSizeInBits(), addr);
         return true;
       }
       break;
     case Value::ConstantIntVal:
       if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) {
         value = constant_int->getValue();

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

bool IRForTarget::RewriteObjCConstString(llvm::GlobalVariable *ns_str,
   Type *i8_ty = Type::getInt8Ty(m_module->getContext());
 
   if (!m_CFStringCreateWithBytes) {
     lldb::addr_t CFStringCreateWithBytes_addr;
 
     static lldb_private::ConstString g_CFStringCreateWithBytes_str(
         "CFStringCreateWithBytes");
 
+    bool missing_weak = false;
     CFStringCreateWithBytes_addr =
-        m_execution_unit.FindSymbol(g_CFStringCreateWithBytes_str);
-    if (CFStringCreateWithBytes_addr == LLDB_INVALID_ADDRESS) {
+        m_execution_unit.FindSymbol(g_CFStringCreateWithBytes_str, 
+                                    missing_weak);
+    if (CFStringCreateWithBytes_addr == LLDB_INVALID_ADDRESS || missing_weak) {
       if (log)
         log->PutCString("Couldn't find CFStringCreateWithBytes in the target");
 
       m_error_stream.Printf("Error [IRForTarget]: Rewriting an Objective-C "
                             "constant string requires "
                             "CFStringCreateWithBytes\n");
 
       return false;
if (log)
     log->Printf("Found Objective-C selector reference \"%s\"",
                 omvn_initializer_string.c_str());
 
   // Construct a call to sel_registerName
 
   if (!m_sel_registerName) {
     lldb::addr_t sel_registerName_addr;
 
+    bool missing_weak = false;
     static lldb_private::ConstString g_sel_registerName_str("sel_registerName");
-    sel_registerName_addr = m_execution_unit.FindSymbol(g_sel_registerName_str);
-    if (sel_registerName_addr == LLDB_INVALID_ADDRESS)
+    sel_registerName_addr = m_execution_unit.FindSymbol(g_sel_registerName_str,
+                                                        missing_weak);
+    if (sel_registerName_addr == LLDB_INVALID_ADDRESS || missing_weak)
       return false;
 
     if (log)
       log->Printf("Found sel_registerName at 0x%" PRIx64,
                   sel_registerName_addr);
 
     // Build the function type: struct objc_selector
     // *sel_registerName(uint8_t*)
if (log)
     log->Printf("Found Objective-C class reference \"%s\"",
                 ocn_initializer_string.c_str());
 
   // Construct a call to objc_getClass
 
   if (!m_objc_getClass) {
     lldb::addr_t objc_getClass_addr;
 
+    bool missing_weak = false;
     static lldb_private::ConstString g_objc_getClass_str("objc_getClass");
-    objc_getClass_addr = m_execution_unit.FindSymbol(g_objc_getClass_str);
-    if (objc_getClass_addr == LLDB_INVALID_ADDRESS)
+    objc_getClass_addr = m_execution_unit.FindSymbol(g_objc_getClass_str,
+                                                     missing_weak);
+    if (objc_getClass_addr == LLDB_INVALID_ADDRESS || missing_weak)
       return false;
 
     if (log)
       log->Printf("Found objc_getClass at 0x%" PRIx64,
                   objc_getClass_addr);
 
     // Build the function type: %struct._objc_class *objc_getClass(i8*)
 

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

if (nlist_data.GetByteSize() > 0) {
 
           sym[sym_idx].SetID(nlist_idx);
           sym[sym_idx].SetType(type);
           if (set_value) {
             sym[sym_idx].GetAddressRef().SetSection(symbol_section);
             sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
           }
           sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
+          if (nlist.n_desc & N_WEAK_REF)
+            sym[sym_idx].SetIsWeak(true);
 
           if (symbol_byte_size > 0)
             sym[sym_idx].SetByteSize(symbol_byte_size);
 
           if (demangled_is_synthesized)
             sym[sym_idx].SetDemangledNameIsSynthesized(true);
 
           ++sym_idx;

lldb/trunk/source/Symbol/Symbol.cpp

 using namespace lldb_private;
 
 Symbol::Symbol()
     : SymbolContextScope(), m_uid(UINT32_MAX), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(false), m_is_debug(false),
       m_is_external(false), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(false),
       m_demangled_is_synthesized(false), m_contains_linker_annotations(false),
-      m_type(eSymbolTypeInvalid), m_mangled(), m_addr_range(), m_flags() {}
+      m_is_weak(false), m_type(eSymbolTypeInvalid), m_mangled(), m_addr_range(),
+      m_flags() {}
 
 Symbol::Symbol(uint32_t symID, const char *name, bool name_is_mangled,
                SymbolType type, bool external, bool is_debug,
                bool is_trampoline, bool is_artificial,
                const lldb::SectionSP &section_sp, addr_t offset, addr_t size,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(is_artificial),
       m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(size_is_valid || size > 0),
       m_demangled_is_synthesized(false),
-      m_contains_linker_annotations(contains_linker_annotations), m_type(type),
+      m_contains_linker_annotations(contains_linker_annotations), 
+      m_is_weak(false), m_type(type),
       m_mangled(ConstString(name), name_is_mangled),
       m_addr_range(section_sp, offset, size), m_flags(flags) {}
 
 Symbol::Symbol(uint32_t symID, const Mangled &mangled, SymbolType type,
                bool external, bool is_debug, bool is_trampoline,
                bool is_artificial, const AddressRange &range,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(is_artificial),
       m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false),
       m_size_is_valid(size_is_valid || range.GetByteSize() > 0),
       m_demangled_is_synthesized(false),
-      m_contains_linker_annotations(contains_linker_annotations), m_type(type),
-      m_mangled(mangled), m_addr_range(range), m_flags(flags) {}
+      m_contains_linker_annotations(contains_linker_annotations), 
+      m_is_weak(false), m_type(type), m_mangled(mangled), m_addr_range(range), 
+      m_flags(flags) {}
 
 Symbol::Symbol(const Symbol &rhs)
     : SymbolContextScope(rhs), m_uid(rhs.m_uid), m_type_data(rhs.m_type_data),
       m_type_data_resolved(rhs.m_type_data_resolved),
       m_is_synthetic(rhs.m_is_synthetic), m_is_debug(rhs.m_is_debug),
       m_is_external(rhs.m_is_external),
       m_size_is_sibling(rhs.m_size_is_sibling), m_size_is_synthesized(false),
       m_size_is_valid(rhs.m_size_is_valid),
       m_demangled_is_synthesized(rhs.m_demangled_is_synthesized),
       m_contains_linker_annotations(rhs.m_contains_linker_annotations),
-      m_type(rhs.m_type), m_mangled(rhs.m_mangled),
+      m_is_weak(rhs.m_is_weak), m_type(rhs.m_type), m_mangled(rhs.m_mangled),
       m_addr_range(rhs.m_addr_range), m_flags(rhs.m_flags) {}
 
 const Symbol &Symbol::operator=(const Symbol &rhs) {
   if (this != &rhs) {
     SymbolContextScope::operator=(rhs);
     m_uid = rhs.m_uid;
     m_type_data = rhs.m_type_data;
     m_type_data_resolved = rhs.m_type_data_resolved;
     m_is_synthetic = rhs.m_is_synthetic;
     m_is_debug = rhs.m_is_debug;
     m_is_external = rhs.m_is_external;
     m_size_is_sibling = rhs.m_size_is_sibling;
     m_size_is_synthesized = rhs.m_size_is_sibling;
     m_size_is_valid = rhs.m_size_is_valid;
     m_demangled_is_synthesized = rhs.m_demangled_is_synthesized;
     m_contains_linker_annotations = rhs.m_contains_linker_annotations;
+    m_is_weak = rhs.m_is_weak;
     m_type = rhs.m_type;
     m_mangled = rhs.m_mangled;
     m_addr_range = rhs.m_addr_range;
     m_flags = rhs.m_flags;
   }
   return *this;
 }
 
 void Symbol::Clear() {
   m_uid = UINT32_MAX;
   m_mangled.Clear();
   m_type_data = 0;
   m_type_data_resolved = false;
   m_is_synthetic = false;
   m_is_debug = false;
   m_is_external = false;
   m_size_is_sibling = false;
   m_size_is_synthesized = false;
   m_size_is_valid = false;
   m_demangled_is_synthesized = false;
   m_contains_linker_annotations = false;
+  m_is_weak = false;
   m_type = eSymbolTypeInvalid;
   m_flags = 0;
   m_addr_range.Clear();
 }
 
 bool Symbol::ValueIsAddress() const {
   return m_addr_range.GetBaseAddress().GetSection().get() != nullptr;
 }