Add functionality for rewriting symbols

[fjricci]

Summary

Clang supports symbol rewrites via the -frewrite-map-file flag,
this patch adds complementary functionality in lldb.

Re-written symbols are required when, for example, two versions of the
same library are linked to the same binary, and the user needs to
differentiate the symbols.

The SymbolRewriter implemented in this patch will use a rewrite map
provided via the 'target symbols rewrite' command to lookup the original
symbol names instead of the names re-written by clang.

[labath]

Mostly just comments about the test from me.

include/lldb/Core/Module.h

240

The const, as specified here is useless. const SP & avoids a copy, shared_ptr<const SymbolRewriter> ensures the rewriter cannot be modified. You probably want one of those.

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/TestSymbolRewriter.py

20

If these compilers don't even support the features, go with skip instead of xfail.

28

This is not going to work for remote targets on different architectures. If you don't need debug info, could you just avoid generating it in the first place (-g0 ?). Maybe then you would be able to get this working on windows as well.
If it doesn't work, then we should wire up this call to go through the Makefile, as it already knows how to find the right toolchain for cross-compilation.

[fjricci]

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/TestSymbolRewriter.py

28

Unfortunately, the '-g0' override will only work for dwarf tests. However, based on TestWithLimitDebugInfo, it looks like we can skip the test for non-dwarf symbols (@skipIf(debug_info=no_match(["dwarf"]))). I think this is probably the cleanest way to go.

[fjricci]

Fix const SP and update unit test

Will now only run the unit test as a dwarf test (with -g0),
but since we don't want to test the debug data anyway,
this shouldn't be an issue, and avoids the use of strip.

[clayborg]

If you can't get this right when debug info is present then I would rather not have this patch. We enabled debug info on your test and it will call the putchar() in the current library so this test will fail and I question the viability of the usefulness of this feature.

Also if you can get that fixed, should the rewrite map actually be associated with a target? Shouldn't the rewrite map just be associated with a lldb_private::Module instead? It doesn't seem like you would want this at the target level. And the command should be "target modules rewrite add --clang-rewrite-file rewrite.map". It is ok to store the rewrite map in the target, but there should probably be a map of module to SymbolRewriter in the target.

In general if we add a member variable to ModuleList that is a SymbolRewriterSP, then many of the target->GetImages().FindXXX calls don't need a new parameter.

Also see inlined comments.

If this can't coexist with debug info I would rather not have this patch.

include/lldb/Core/ModuleList.h

272

We should add a member variable to ModuleList:

lldb::SymbolRewriterSP m_rewriter_sp;

Then have target place the lldb::SymbolRewriterSP into it's module list. Then this extra parameter shouldn't be needed.

284

Ditto above comment

408

Ditto above comment

include/lldb/Target/Target.h

1139–1149

Why are we making a lldb::SymbolRewriterSP here? This should return an empty lldb::SymbolRewriterSP if no one has called the "target symbols rewrite" function. Any callers should check for an empty shared pointer before using it.

1626

any shared pointers should have a _sp suffix.

source/API/SBTarget.cpp

1805–1811

This isn't needed if you allow ModuleList to have a "lldb::SymbolRewriterSP m_rewriter_sp;" member variable. Remove this.

1837

This isn't needed if you allow ModuleList to have a "lldb::SymbolRewriterSP m_rewriter_sp;" member variable. Remove this.

2390–2394

This isn't needed if you allow ModuleList to have a "lldb::SymbolRewriterSP m_rewriter_sp;" member variable. Remove this.

source/Breakpoint/BreakpointResolverName.cpp

237

You might need to ask the target to get the rewriter for a specific module:

lldb::SymbolRewriterSP rewriter = context.target_sp ? context.target_sp->GetSymbolRewriterForModule(context.module_sp) : nullptr;

It depends on if the rewrite maps should be associated with a given module, or if they truly are global and apply to all modules?

Also add a "_sp" suffix to any variables that are shared pointers.

source/Commands/CommandObjectSource.cpp

428–434

This isn't needed if you allow ModuleList to have a "lldb::SymbolRewriterSP m_rewriter_sp;" member variable. Remove this.

[clayborg]

Adding a feature to the debugger that doesn't work with debug info seems like a bad idea.

[jingham]

This approach seems fragile to me. I'm supposed to remember that some build system set some rewriter file that I then have to supply manually to get the view of symbols to match reality? We really try to avoid having to write notes on little pieces of paper and typing them back in to get debugging to work...

This should get recorded somewhere in the module that uses it, and then the module reader code would be able to find and apply it automatically. If this is passed to the compiler, it should get written into the DWARF. But it sounds more like it gets passed to then linker. So maybe we can stick this map file in a load command, or symbol that the symbol file reader can fetch.

You might need a command to give search paths for these remap files in case you move the around, but that's all that the user should need to do by hand.

[clayborg]

Adrian Prantl suggested that we modify clang to update the debug info for the function. In the test case that was attached, the DWARF currently has a "putchar" function which should get a linkage name attached to it with "__my_putchar". Then the debug info can be correct and we won't need any modifications of the rewrite file stuff.

[sas]

@jingham, @clayborg, this is indeed a bit fragile as having to specify your rewrite maps manually when debugging is very error-prone. I have a patch that fetches the path to the rewrite map from the debug info, I'm waiting for this one to go in to upload that other diff (trying to make changes smaller so the review is easier). The way I do this is by looking at the flags that were passed to the compiler, and get the path to the rewrite map from there automatically, which then requires no user interaction for this to work.

[fjricci]

@clayborg: As you saw when running the test with debug info enabled, we might end up calling the non-rewritten putchar(), which is due to the compiler emitting debug symbols with the non-rewritten name. The -g0 option is just a workaround until we can fix that.

I suppose Adrian Prantl's idea of modifying the emitted DWARF to add a linkage name attached to the function would work. Does that mean we would only add an entry for the rewritten symbol when lldb parses the DWARF, and ignore the non-rewritten function name?

[clayborg]

In D22294#483213, @sas wrote:

@jingham, @clayborg, this is indeed a bit fragile as having to specify your rewrite maps manually when debugging is very error-prone. I have a patch that fetches the path to the rewrite map from the debug info, I'm waiting for this one to go in to upload that other diff (trying to make changes smaller so the review is easier). The way I do this is by looking at the flags that were passed to the compiler, and get the path to the rewrite map from there automatically, which then requires no user interaction for this to work.

If we have the compiler modify the DWARF by adding a linkage name to the appropriate DW_TAG_subproggram, then we won't need any rewrite file stuff at all.

In D22294#483242, @fjricci wrote:

@clayborg: As you saw when running the test with debug info enabled, we might end up calling the non-rewritten putchar(), which is due to the compiler emitting debug symbols with the non-rewritten name. The -g0 option is just a workaround until we can fix that.

I suppose Adrian Prantl's idea of modifying the emitted DWARF to add a linkage name attached to the function would work. Does that mean we would only add an entry for the rewritten symbol when lldb parses the DWARF, and ignore the non-rewritten function name?

Basically the DWARF currently looks like:

0x0000002e:     DW_TAG_subprogram [2] *
                 DW_AT_low_pc( 0x0000000000000000 )
                 DW_AT_high_pc( 0x000000000000000e )
                 DW_AT_frame_base( rbp )
                 DW_AT_name( "putchar" )
                 DW_AT_decl_file( "/Volumes/work/gclayton/Desktop/symbol_rewriter/main.c" )
                 DW_AT_decl_line( 3 )
                 DW_AT_prototyped( 0x01 )
                 DW_AT_type( {0x0000007a} ( int ) )
                 DW_AT_external( 0x01 )

And we would modify it to emit this:

0x0000002e:     DW_TAG_subprogram [2] *
                 DW_AT_low_pc( 0x0000000000000000 )
                 DW_AT_high_pc( 0x000000000000000e )
                 DW_AT_frame_base( rbp )
                 DW_AT_name( "putchar" )
                 DW_AT_linkage_name( "__my_putchar" ) <<< Added by compiler
                 DW_AT_decl_file( "/Volumes/work/gclayton/Desktop/symbol_rewriter/main.c" )
                 DW_AT_decl_line( 3 )
                 DW_AT_prototyped( 0x01 )
                 DW_AT_type( {0x0000007a} ( int ) )
                 DW_AT_external( 0x01 )

If we do this, then we don't need any modifications for the rewrite stuff at all?

[sas]

In D22294#483250, @clayborg wrote:

In D22294#483213, @sas wrote:

@jingham, @clayborg, this is indeed a bit fragile as having to specify your rewrite maps manually when debugging is very error-prone. I have a patch that fetches the path to the rewrite map from the debug info, I'm waiting for this one to go in to upload that other diff (trying to make changes smaller so the review is easier). The way I do this is by looking at the flags that were passed to the compiler, and get the path to the rewrite map from there automatically, which then requires no user interaction for this to work.

If we have the compiler modify the DWARF by adding a linkage name to the appropriate DW_TAG_subproggram, then we won't need any rewrite file stuff at all.

In D22294#483242, @fjricci wrote:

@clayborg: As you saw when running the test with debug info enabled, we might end up calling the non-rewritten putchar(), which is due to the compiler emitting debug symbols with the non-rewritten name. The -g0 option is just a workaround until we can fix that.

I suppose Adrian Prantl's idea of modifying the emitted DWARF to add a linkage name attached to the function would work. Does that mean we would only add an entry for the rewritten symbol when lldb parses the DWARF, and ignore the non-rewritten function name?

Basically the DWARF currently looks like:

0x0000002e:     DW_TAG_subprogram [2] *
                 DW_AT_low_pc( 0x0000000000000000 )
                 DW_AT_high_pc( 0x000000000000000e )
                 DW_AT_frame_base( rbp )
                 DW_AT_name( "putchar" )
                 DW_AT_decl_file( "/Volumes/work/gclayton/Desktop/symbol_rewriter/main.c" )
                 DW_AT_decl_line( 3 )
                 DW_AT_prototyped( 0x01 )
                 DW_AT_type( {0x0000007a} ( int ) )
                 DW_AT_external( 0x01 )

And we would modify it to emit this:

0x0000002e:     DW_TAG_subprogram [2] *
                 DW_AT_low_pc( 0x0000000000000000 )
                 DW_AT_high_pc( 0x000000000000000e )
                 DW_AT_frame_base( rbp )
                 DW_AT_name( "putchar" )
                 DW_AT_linkage_name( "__my_putchar" ) <<< Added by compiler
                 DW_AT_decl_file( "/Volumes/work/gclayton/Desktop/symbol_rewriter/main.c" )
                 DW_AT_decl_line( 3 )
                 DW_AT_prototyped( 0x01 )
                 DW_AT_type( {0x0000007a} ( int ) )
                 DW_AT_external( 0x01 )

If we do this, then we don't need any modifications for the rewrite stuff at all?

I think some understanding of the rewrites from the debugger is still required because the user will still enter commands like call putchar('a') and expect the putchar() they wrote to be called. That putchar() they expect is now called _my_putchar() and unless we rewrite the symbol they typed, they'll end up calling the non-rewritten putchar().

One thing to note is that adding the DW_AT_linkage_name entry to DW_TAG_subprogram will fix the bug that we are working around in the unit tests with -g0, so that is required regardless.

[clayborg]

I think some understanding of the rewrites from the debugger is still required because the user will still enter commands like call putchar('a') and expect the putchar() they wrote to be called. That putchar() they expect is now called _my_putchar() and unless we rewrite the symbol they typed, they'll end up calling the non-rewritten putchar().

No, the function lookup will find both "putchar" and "_my_putchar" will be found in your debug info and map to an address that matches the symbol for "_my_putchar". So no rewrite stuff will be needed.

One thing to note is that adding the DW_AT_linkage_name entry to DW_TAG_subprogram will fix the bug that we are working around in the unit tests with -g0, so that is required regardless.

So the way LLDB resolves functions is the function lookup happens for "putchar". If multiple results are found, then we prefer the one from the current executable, which means we will use the local "putchar". If we find multiple and none are in the current shared library we will note that there are duplicates and the expression will fail.

So I vote we fix the DWARF and be done.

[clayborg]

Note that during function lookup, we can find both "putchar" and "__my_putchar" in the debug info, so you will be able to call both.

[sas]

In D22294#483264, @clayborg wrote:

Note that during function lookup, we can find both "putchar" and "__my_putchar" in the debug info, so you will be able to call both.

Correct, unless as you pointed out both symbols are in libraries, and not in the main executable.

Our experience using this feature of clang has been that both symbols being in libraries is the rule rather than the exception.

See r221548 in llvm which introduces the symbol rewriter pass. This functionality is used for things like interposing of libraries, etc, or experiments where two versions of the same library are running alongside each other. This means that in the general use case, you have both the non-rewritten as well as the rewritten library loaded in the process.

FWIW, the current version of lldb is already able to call _my_putchar, given that this is the name present in the Mach-O symbol table.

[jingham]

We always resolve duplicate symbols to the "closest" one to the current frame. So if there are two versions of putchar and one is in the library containing the current frame, we should find that one. If we aren't getting that right, that's a bug. So the correct symbol should get called in cases where it makes sense. But if you are in main, and you have two libraries with rewritten putchar's it isn't clear which one we should call, and I think it isn't all that unexpected that we would just raise an error. If the duplicate symbols are both exported, but there's other linker magic to pick one over the other in main, then we'd have to know about that to get the right symbol. But I think that's orthogonal to this discussion.

Jim

[clayborg]

In D22294#483311, @sas wrote:

In D22294#483264, @clayborg wrote:

Note that during function lookup, we can find both "putchar" and "__my_putchar" in the debug info, so you will be able to call both.

Correct, unless as you pointed out both symbols are in libraries, and not in the main executable.

Our experience using this feature of clang has been that both symbols being in libraries is the rule rather than the exception.

See r221548 in llvm which introduces the symbol rewriter pass. This functionality is used for things like interposing of libraries, etc, or experiments where two versions of the same library are running alongside each other. This means that in the general use case, you have both the non-rewritten as well as the rewritten library loaded in the process.

FWIW, the current version of lldb is already able to call _my_putchar, given that this is the name present in the Mach-O symbol table.

And adding the rewriting stuff does nothing to help these duplicate symbols. If you are not stopped in a.out, and you try to call putchar, your expression will fail with duplicate symbols even with your rewriting stuff. So there is no need to add it. Just fix the DWARF.

include/lldb/Core/Module.h

// ModuleList). If this is the case we need to know about it.
     ///     symbols that match \a symbol_type.
     ///
     /// @return
     ///     Returns a valid symbol pointer if a symbol was found,
     ///     nullptr otherwise.
     //------------------------------------------------------------------
     const Symbol *
     FindFirstSymbolWithNameAndType (const ConstString &name, 
+                                    const lldb::SymbolRewriterSP rewriter,
                                     lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
 
     size_t
     FindSymbolsWithNameAndType (const ConstString &name,
+                                const lldb::SymbolRewriterSP rewriter,
                                 lldb::SymbolType symbol_type, 
                                 SymbolContextList &sc_list);
 
     size_t
     FindSymbolsMatchingRegExAndType (const RegularExpression &regex, 
                                      lldb::SymbolType symbol_type, 
                                      SymbolContextList &sc_list);
 
     //------------------------------------------------------------------
     /// Find a funciton symbols in the object file's symbol table.
     ///
     /// @param[in] name
     ///     The name of the symbol that we are looking for.
     ///
+    /// @param[in] rewriter
+    ///     A symbol name rewriter.
+    ///
     /// @param[in] name_type_mask
     ///     A mask that has one or more bitwise OR'ed values from the
     ///     lldb::FunctionNameType enumeration type that indicate what
     ///     kind of names we are looking for.
     ///
     /// @param[out] sc_list
     ///     A list to append any matching symbol contexts to.
     ///
     /// @return
     ///     The number of symbol contexts that were added to \a sc_list
     //------------------------------------------------------------------
     size_t
     FindFunctionSymbols (const ConstString &name,
+                         const lldb::SymbolRewriterSP rewriter,
                          uint32_t name_type_mask,
                          SymbolContextList& sc_list);
 
     //------------------------------------------------------------------
     /// Find compile units by partial or full path.
     ///
     /// Finds all compile units that match \a path in all of the modules
     /// and returns the results in \a sc_list.
// ModuleList). If this is the case we need to know about it.
     ///     A symbol context list that gets filled in with all of the
     ///     matches.
     ///
     /// @return
     ///     The number of matches added to \a sc_list.
     //------------------------------------------------------------------
     size_t
     FindFunctions (const ConstString &name,
+                   const lldb::SymbolRewriterSP rewriter,
                    const CompilerDeclContext *parent_decl_ctx,
                    uint32_t name_type_mask, 
                    bool symbols_ok,
                    bool inlines_ok,
                    bool append, 
                    SymbolContextList& sc_list);
 
     //------------------------------------------------------------------
GetSourceMappingList ()
         return m_source_mappings;
     }
     
     const PathMappingList &
     GetSourceMappingList () const
     {
         return m_source_mappings;
     }
-    
     //------------------------------------------------------------------
     /// Finds a source file given a file spec using the module source
     /// path remappings (if any).
     ///
     /// Tries to resolve \a orig_spec by checking the module source path
     /// remappings. It makes sure the file exists, so this call can be
     /// expensive if the remappings are on a network file system, so
     /// use this function sparingly (not in a tight debug info parsing

include/lldb/Core/ModuleList.h

FindCompileUnits (const FileSpec &path,
                       bool append,
                       SymbolContextList &sc_list) const;
     
     //------------------------------------------------------------------
     /// @see Module::FindFunctions ()
     //------------------------------------------------------------------
     size_t
     FindFunctions (const ConstString &name,
+                   const lldb::SymbolRewriterSP rewriter,
                    uint32_t name_type_mask,
                    bool include_symbols,
                    bool include_inlines,
                    bool append,
                    SymbolContextList &sc_list) const;
 
     //------------------------------------------------------------------
     /// @see Module::FindFunctionSymbols ()
     //------------------------------------------------------------------
     size_t
     FindFunctionSymbols (const ConstString &name,
+                         const lldb::SymbolRewriterSP rewriter,
                          uint32_t name_type_mask,
                          SymbolContextList& sc_list);
 
     //------------------------------------------------------------------
     /// @see Module::FindFunctions ()
     //------------------------------------------------------------------
     size_t
         FindFunctions(const RegularExpression &name,
public:
     lldb::ModuleSP
     FindModule (const UUID &uuid) const;
     
     lldb::ModuleSP
     FindFirstModule (const ModuleSpec &module_spec) const;
 
     size_t
     FindSymbolsWithNameAndType (const ConstString &name,
+                                const lldb::SymbolRewriterSP rewriter,
                                 lldb::SymbolType symbol_type,
                                 SymbolContextList &sc_list,
                                 bool append = false) const;
 
     size_t
     FindSymbolsMatchingRegExAndType (const RegularExpression &regex, 
                                      lldb::SymbolType symbol_type, 
                                      SymbolContextList &sc_list,

include/lldb/Symbol/SymbolRewriter.h

+//===-- SymbolRewriter.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_SymbolRewriter_h_
+#define liblldb_SymbolRewriter_h_
+
+#include "lldb/Core/ConstString.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/lldb-defines.h"
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+
+namespace lldb_private {
+
+//-----------------------------------------------------------------------
+/// @class SymbolRewriter SymbolRewriter.h "lldb/Symbol/SymbolRewriter.h"
+/// @brief Implementation of the symbol rewrite mechanism.
+//-----------------------------------------------------------------------
+class SymbolRewriter
+{
+private:
+    struct RewriteMap
+    {
+        std::map<ConstString, ConstString> m_direct_map;
+        std::map<ConstString, ConstString> m_transform_map;
+    };
+
+    typedef std::shared_ptr<RewriteMap> RewriteMapSP;
+
+public:
+    SymbolRewriter ();
+
+    virtual
+    ~SymbolRewriter() {}
+
+    // Load a rewrite map and add its contents to the list of rewrites.
+    void
+    LoadMap (const FileSpec &path);
+
+    std::list<RewriteMapSP>::size_type
+    GetMapCount() const
+    {
+        return m_rewrite_maps.size ();
+    }
+
+    ConstString
+    Rewrite (const ConstString &name);
+
+private:
+    std::list<RewriteMapSP> m_rewrite_maps;
+
+    DISALLOW_COPY_AND_ASSIGN (SymbolRewriter);
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_SymbolRewriter_h_

include/lldb/Symbol/Symtab.h

const   Symbol *    GetParent (Symbol *symbol) const;
             uint32_t    AppendSymbolIndexesWithTypeAndFlagsValue (lldb::SymbolType symbol_type, uint32_t flags_value, std::vector<uint32_t>& indexes, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
             uint32_t    AppendSymbolIndexesWithType (lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches, uint32_t start_idx = 0, uint32_t end_index = UINT32_MAX) const;
             uint32_t    AppendSymbolIndexesWithName (const ConstString& symbol_name, std::vector<uint32_t>& matches);
             uint32_t    AppendSymbolIndexesWithName (const ConstString& symbol_name, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches);
             uint32_t    AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, lldb::SymbolType symbol_type, std::vector<uint32_t>& matches);
             uint32_t    AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& matches);
             uint32_t    AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector<uint32_t>& indexes);
             uint32_t    AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes);
-            size_t      FindAllSymbolsWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes);
-            size_t      FindAllSymbolsWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
+            size_t      FindAllSymbolsWithNameAndType (const ConstString &name, const lldb::SymbolRewriterSP rewriter, lldb::SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes);
+            size_t      FindAllSymbolsWithNameAndType (const ConstString &name, const lldb::SymbolRewriterSP rewriter, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
             size_t      FindAllSymbolsMatchingRexExAndType (const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes);
-            Symbol *    FindFirstSymbolWithNameAndType (const ConstString &name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility);
+            Symbol *    FindFirstSymbolWithNameAndType (const ConstString &name, const lldb::SymbolRewriterSP rewriter, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility);
             Symbol *    FindSymbolAtFileAddress (lldb::addr_t file_addr);
             Symbol *    FindSymbolContainingFileAddress (lldb::addr_t file_addr);
             void        ForEachSymbolContainingFileAddress(lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
-            size_t      FindFunctionSymbols (const ConstString &name, uint32_t name_type_mask, SymbolContextList& sc_list);
+            size_t      FindFunctionSymbols (const ConstString &name, const lldb::SymbolRewriterSP rewriter, uint32_t name_type_mask, SymbolContextList& sc_list);
             void        CalculateSymbolSizes ();
 
             void        SortSymbolIndexesByValue (std::vector<uint32_t>& indexes, bool remove_duplicates) const;
 
     static  void        DumpSymbolHeader (Stream *s);
 
     
             void        Finalize ()
CheckSymbolAtIndex (size_t idx, Debug symbol_debug_type, Visibility symbol_visibility) const
         }
         return false;
     }
 
     void
     SymbolIndicesToSymbolContextList (std::vector<uint32_t> &symbol_indexes,
                                       SymbolContextList &sc_list);
 
+    ConstString
+    RewriteName (const lldb::SymbolRewriterSP rewriter, ConstString name);
+
     DISALLOW_COPY_AND_ASSIGN (Symtab);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_Symtab_h_

include/lldb/Target/Target.h

 #include "lldb/Breakpoint/BreakpointList.h"
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Expression/Expression.h"
+#include "lldb/Symbol/SymbolRewriter.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/PathMappingList.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/SectionLoadHistory.h"
 
 namespace lldb_private {
 
GetImages () const
         return m_images;
     }
     
     ModuleList&
     GetImages ()
     {
         return m_images;
     }
-    
+    lldb::SymbolRewriterSP
+    GetSymbolRewriter ()
+    {
+        if (!m_symbol_rewriter)
+        {
+            m_symbol_rewriter = std::make_shared<SymbolRewriter>();
+        }
+
+        return m_symbol_rewriter;
+    }
+    
     //------------------------------------------------------------------
     /// Return whether this FileSpec corresponds to a module that should be considered for general searches.
     ///
     /// This API will be consulted by the SearchFilterForUnconstrainedSearches
     /// and any module that returns \b true will not be searched.  Note the
     /// SearchFilterForUnconstrainedSearches is the search filter that
     /// gets used in the CreateBreakpoint calls when no modules is provided.
     ///
protected:
     // Member variables.
     //------------------------------------------------------------------
     Debugger &      m_debugger;
     lldb::PlatformSP m_platform_sp;     ///< The platform for this target.
     std::recursive_mutex
         m_mutex; ///< An API mutex that is used by the lldb::SB* classes make the SB interface thread safe
     ArchSpec        m_arch;
     ModuleList      m_images;           ///< The list of images for this process (shared libraries and anything dynamically loaded).
+    lldb::SymbolRewriterSP m_symbol_rewriter; ///< Symbol rewriter for the target.
     SectionLoadHistory m_section_load_history;
     BreakpointList  m_breakpoint_list;
     BreakpointList  m_internal_breakpoint_list;
     lldb::BreakpointSP m_last_created_breakpoint;
     WatchpointList  m_watchpoint_list;
     lldb::WatchpointSP m_last_created_watchpoint;
     // We want to tightly control the process destruction process so
     // we can correctly tear down everything that we need to, so the only

include/lldb/lldb-forward.h

 class   TypeSummaryOptions;
 class   Symbol;
 class   SymbolContext;
 class   SymbolContextList;
 class   SymbolContextScope;
 class   SymbolContextSpecifier;
 class   SymbolFile;
 class   SymbolFileType;
+class   SymbolRewriter;
 class   SymbolVendor;
 class   Symtab;
 class   SyntheticChildren;
 class   SyntheticChildrenFrontEnd;
 class   TypeFilterImpl;
 class   TypeSystem;
 #ifndef LLDB_DISABLE_PYTHON
 class   ScriptedSyntheticChildren;
namespace lldb {
     typedef std::shared_ptr<lldb_private::Stream> StreamSP;
     typedef std::weak_ptr<lldb_private::Stream> StreamWP;
     typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;
     typedef std::shared_ptr<lldb_private::StringSummaryFormat> StringTypeSummaryImplSP;
     typedef std::shared_ptr<lldb_private::SymbolFile> SymbolFileSP;
     typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
     typedef std::weak_ptr<lldb_private::SymbolFileType> SymbolFileTypeWP;
     typedef std::shared_ptr<lldb_private::SymbolContextSpecifier> SymbolContextSpecifierSP;
+    typedef std::shared_ptr<lldb_private::SymbolRewriter> SymbolRewriterSP;
     typedef std::unique_ptr<lldb_private::SymbolVendor> SymbolVendorUP;
     typedef std::shared_ptr<lldb_private::SyntheticChildren> SyntheticChildrenSP;
     typedef std::shared_ptr<lldb_private::SyntheticChildrenFrontEnd> SyntheticChildrenFrontEndSP;
     typedef std::shared_ptr<lldb_private::Target> TargetSP;
     typedef std::weak_ptr<lldb_private::Target> TargetWP;
     typedef std::shared_ptr<lldb_private::TargetProperties> TargetPropertiesSP;
     typedef std::shared_ptr<lldb_private::Thread> ThreadSP;
     typedef std::weak_ptr<lldb_private::Thread> ThreadWP;

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     6D86CEA01B440F8500A7FBFA /* CommandObjectBugreport.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D86CE9E1B440F6B00A7FBFA /* CommandObjectBugreport.cpp */; };
     6D95DC001B9DC057000E318A /* DIERef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFD1B9DC057000E318A /* DIERef.cpp */; };
     6D95DC011B9DC057000E318A /* HashedNameToDIE.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */; };
     6D95DC021B9DC057000E318A /* SymbolFileDWARFDwo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */; };
     6D99A3631BBC2F3200979793 /* ArmUnwindInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D99A3621BBC2F3200979793 /* ArmUnwindInfo.cpp */; };
     6D9AB3DD1BB2B74E003F2289 /* TypeMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D9AB3DC1BB2B74E003F2289 /* TypeMap.cpp */; };
     6DEC6F391BD66D750091ABA6 /* TaskPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DEC6F381BD66D750091ABA6 /* TaskPool.cpp */; };
     8C26C4261C3EA5F90031DF7C /* ThreadSanitizerRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C26C4241C3EA4340031DF7C /* ThreadSanitizerRuntime.cpp */; };
+    5AB29E881AD3510900C69791 /* SymbolRewriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5AB29E871AD3510900C69791 /* SymbolRewriter.cpp */; };
     8C2D6A53197A1EAF006989C9 /* MemoryHistory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */; };
     8C2D6A5E197A250F006989C9 /* MemoryHistoryASan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */; };
     8CCB017E19BA28A80009FD44 /* ThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */; };
     8CCB018219BA4E270009FD44 /* SBThreadCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 8CCB018119BA4E210009FD44 /* SBThreadCollection.h */; settings = {ATTRIBUTES = (Public, ); }; };
     8CCB018319BA51BF0009FD44 /* SBThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */; };
     8CF02AE919DCC01900B14BE0 /* InstrumentationRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */; };
     8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */; };
     8CF02AEF19DD16B100B14BE0 /* InstrumentationRuntimeStopInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */; };

     4CD0BD0C134BFAB600CB44D4 /* ValueObjectDynamicValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ValueObjectDynamicValue.h; path = include/lldb/Core/ValueObjectDynamicValue.h; sourceTree = "<group>"; };
     4CD0BD0E134BFADF00CB44D4 /* ValueObjectDynamicValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ValueObjectDynamicValue.cpp; path = source/Core/ValueObjectDynamicValue.cpp; sourceTree = "<group>"; };
     4CE4F672162C971A00F75CB3 /* SBExpressionOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBExpressionOptions.h; path = include/lldb/API/SBExpressionOptions.h; sourceTree = "<group>"; };
     4CE4F674162C973F00F75CB3 /* SBExpressionOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBExpressionOptions.cpp; path = source/API/SBExpressionOptions.cpp; sourceTree = "<group>"; };
     4CE4F676162CE1E100F75CB3 /* SBExpressionOptions.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBExpressionOptions.i; sourceTree = "<group>"; };
     4CEDAED311754F5E00E875A6 /* ThreadPlanStepUntil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ThreadPlanStepUntil.h; path = include/lldb/Target/ThreadPlanStepUntil.h; sourceTree = "<group>"; };
     4CF52AF41428291E0051E832 /* SBFileSpecList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFileSpecList.h; path = include/lldb/API/SBFileSpecList.h; sourceTree = "<group>"; };
     4CF52AF7142829390051E832 /* SBFileSpecList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBFileSpecList.cpp; path = source/API/SBFileSpecList.cpp; sourceTree = "<group>"; };
+    5AB29E871AD3510900C69791 /* SymbolRewriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SymbolRewriter.cpp; path = source/Symbol/SymbolRewriter.cpp; sourceTree = "<group>"; };
     69A01E1B1236C5D400C660B5 /* Condition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Condition.cpp; sourceTree = "<group>"; };
     69A01E1C1236C5D400C660B5 /* Host.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Host.cpp; sourceTree = "<group>"; };
     69A01E1E1236C5D400C660B5 /* Mutex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Mutex.cpp; sourceTree = "<group>"; };
     69A01E1F1236C5D400C660B5 /* Symbols.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Symbols.cpp; sourceTree = "<group>"; };
     69A01E201236C5D400C660B5 /* TimeValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TimeValue.cpp; sourceTree = "<group>"; };
     6D0F613C1C80AA8900A4ECEE /* DebugMacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DebugMacros.h; path = include/lldb/Symbol/DebugMacros.h; sourceTree = "<group>"; };
     6D0F613D1C80AA8900A4ECEE /* JavaASTContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JavaASTContext.h; path = include/lldb/Symbol/JavaASTContext.h; sourceTree = "<group>"; };
     6D0F61411C80AAAA00A4ECEE /* JavaASTContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JavaASTContext.cpp; path = source/Symbol/JavaASTContext.cpp; sourceTree = "<group>"; };
26BC7C4B10F1B6C100F91463 /* Symbol */ = {
         3032B1B61CAAA3D1004BE1AB /* ClangUtil.cpp */,
         6D0F61411C80AAAA00A4ECEE /* JavaASTContext.cpp */,
         6D0F613C1C80AA8900A4ECEE /* DebugMacros.h */,
         6D0F613D1C80AA8900A4ECEE /* JavaASTContext.h */,
         6D9AB3DE1BB2B76B003F2289 /* TypeMap.h */,
         6D9AB3DC1BB2B74E003F2289 /* TypeMap.cpp */,
         6D99A3621BBC2F3200979793 /* ArmUnwindInfo.cpp */,
         6D99A3611BBC2F1600979793 /* ArmUnwindInfo.h */,
+        5AB29E871AD3510900C69791 /* SymbolRewriter.cpp */,
         26BC7C5510F1B6E900F91463 /* Block.h */,
         26BC7F1310F1B8EC00F91463 /* Block.cpp */,
         26BC7C5610F1B6E900F91463 /* ClangASTContext.h */,
         26BC7F1410F1B8EC00F91463 /* ClangASTContext.cpp */,
         49D8FB3713B5594900411094 /* ClangASTImporter.h */,
         49D8FB3513B558DE00411094 /* ClangASTImporter.cpp */,
         265192C41BA8E8F8002F08F6 /* CompilerDecl.h */,
         265192C51BA8E905002F08F6 /* CompilerDecl.cpp */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689000113353DB600698AC0 /* BreakpointResolverAddress.cpp in Sources */,
         255EFF741AFABA720069F277 /* LockFileBase.cpp in Sources */,
         945261C21B9A11FC00BF138D /* LibCxxList.cpp in Sources */,
         2689000313353DB600698AC0 /* BreakpointResolverFileLine.cpp in Sources */,
         26474CA818D0CB070073DEBA /* RegisterContextFreeBSD_i386.cpp in Sources */,
         449ACC98197DEA0B008D175E /* FastDemangle.cpp in Sources */,
         2689000513353DB600698AC0 /* BreakpointResolverName.cpp in Sources */,
         6D762BEE1B1605D2006C929D /* LLDBServerUtilities.cpp in Sources */,
+        5AB29E881AD3510900C69791 /* SymbolRewriter.cpp in Sources */,
         2689000713353DB600698AC0 /* BreakpointSite.cpp in Sources */,
         2689000913353DB600698AC0 /* BreakpointSiteList.cpp in Sources */,
         26474CC918D0CB5B0073DEBA /* RegisterContextMemory.cpp in Sources */,
         8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */,
         26474CB218D0CB180073DEBA /* RegisterContextLinux_i386.cpp in Sources */,
         26474CCB18D0CB5B0073DEBA /* RegisterContextPOSIX_mips64.cpp in Sources */,
         2689000B13353DB600698AC0 /* Stoppoint.cpp in Sources */,
         2689000D13353DB600698AC0 /* StoppointCallbackContext.cpp in Sources */,

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+CFLAGS_EXTRAS += -frewrite-map-file=rewrite.map
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/TestSymbolRewriter.py

+"""Check that compiler-generated constant values work correctly"""
+
+from __future__ import print_function
+
+import os, time
+import subprocess
+
+import lldb
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class SymbolRewriterTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # We need the -frewrite-map-file clang flag to build
+    @expectedFailureAll(compiler="clang", compiler_version=["<", "3.7"])
+    @expectedFailureAll(compiler='gcc')
+    @skipIfWindows
+    def test_and_run_command(self):
+        """Test the lldb symbol rewriter"""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        # Clang does not rewrite dwarf debug info, so it must be stripped
+        subprocess.check_call(['strip', '-g', exe])
+
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Break inside the main.
+        lldbutil.run_break_set_by_symbol (self, "main")
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # Before adding the rewrite map, we will call the system putchar()
+        self.expect("expr (int)putchar('a')", substrs = ['(int) $0 = 97'])
+
+        rewrite_map = os.path.join(os.getcwd(), "rewrite.map")
+        self.runCmd("target symbols rewrite " + rewrite_map)
+
+        # After adding the rewrite map, we will call our re-written putchar()
+        self.expect("expr (int)putchar('a')", substrs = ['(int) $1 = 12345'])
+
+        self.runCmd("kill")

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/main.c

+#include <stdio.h>
+
+int putchar(int c)
+{
+  return 12345;
+}
+
+int main()
+{
+  return putchar('a');
+}

packages/Python/lldbsuite/test/lang/c/symbol_rewriter/rewrite.map

+function: { source: putchar, target: __my_putchar,}

source/API/SBModule.cpp

SBModule::FindSymbol (const char *name,
                       lldb::SymbolType symbol_type)
 {
     SBSymbol sb_symbol;
     if (name && name[0])
     {
         ModuleSP module_sp (GetSP ());
         Symtab *symtab = GetUnifiedSymbolTable (module_sp);
         if (symtab)
-            sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(ConstString(name), symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny));
+            sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(ConstString(name), nullptr, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny));
     }
     return sb_symbol;
 }
 
 
 lldb::SBSymbolContextList
 SBModule::FindSymbols (const char *name, lldb::SymbolType symbol_type)
 {
     SBSymbolContextList sb_sc_list;
     if (name && name[0])
     {
         ModuleSP module_sp (GetSP ());
         Symtab *symtab = GetUnifiedSymbolTable (module_sp);
         if (symtab)
         {
             std::vector<uint32_t> matching_symbol_indexes;
-            const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type, matching_symbol_indexes);
+            const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(ConstString(name), nullptr, symbol_type, matching_symbol_indexes);
             if (num_matches)
             {
                 SymbolContext sc;
                 sc.module_sp = module_sp;
                 SymbolContextList &sc_list = *sb_sc_list;
                 for (size_t i=0; i<num_matches; ++i)
                 {
                     sc.symbol = symtab->SymbolAtIndex (matching_symbol_indexes[i]);
SBModule::FindFunctions (const char *name,
     lldb::SBSymbolContextList sb_sc_list;
     ModuleSP module_sp (GetSP ());
     if (name && module_sp)
     {
         const bool append = true;
         const bool symbols_ok = true;
         const bool inlines_ok = true;
         module_sp->FindFunctions (ConstString(name),
+                                  nullptr,
                                   NULL,
                                   name_type_mask, 
                                   symbols_ok,
                                   inlines_ok,
                                   append, 
                                   *sb_sc_list);
     }
     return sb_sc_list;

source/API/SBTarget.cpp

SBTarget::FindFunctions (const char *name, uint32_t name_type_mask)
     if (name && name[0])
     {
         TargetSP target_sp(GetSP());
         if (target_sp)
         {
             const bool symbols_ok = true;
             const bool inlines_ok = true;
             const bool append = true;
             target_sp->GetImages().FindFunctions (ConstString(name), 
+                                                  target_sp->GetSymbolRewriter(),
                                                   name_type_mask, 
                                                   symbols_ok,
                                                   inlines_ok,
                                                   append, 
                                                   *sb_sc_list);
         }
     }
     return sb_sc_list;
 }
 
 lldb::SBSymbolContextList 
 SBTarget::FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype)
 {
if (name && name[0])
             case eMatchTypeRegex:
                 target_sp->GetImages().FindFunctions(RegularExpression(name), true, true, true, *sb_sc_list);
                 break;
             case eMatchTypeStartsWith:
                 regexstr = llvm::Regex::escape(name) + ".*";
                 target_sp->GetImages().FindFunctions(RegularExpression(regexstr.c_str()), true, true, true, *sb_sc_list);
                 break;
             default:
-                target_sp->GetImages().FindFunctions(ConstString(name), eFunctionNameTypeAny, true, true, true, *sb_sc_list);
+                target_sp->GetImages().FindFunctions(ConstString(name), target_sp->GetSymbolRewriter(), eFunctionNameTypeAny, true, true, true, *sb_sc_list);
                 break;
             }
         }
     }
     return sb_sc_list;
 }
 
 lldb::SBType

 {
     SBSymbolContextList sb_sc_list;
     if (name && name[0])
     {
         TargetSP target_sp(GetSP());
         if (target_sp)
         {
             bool append = true;
             target_sp->GetImages().FindSymbolsWithNameAndType (ConstString(name),
+                                                               target_sp->GetSymbolRewriter(),
                                                                symbol_type,
                                                                *sb_sc_list,
                                                                append);
         }
     }
     return sb_sc_list;
     
 }
 
 lldb::SBValue
 SBTarget::EvaluateExpression (const char *expr)

source/Breakpoint/BreakpointResolverName.cpp

 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/Target.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
                                                 const char *name_cstr,
                                                 uint32_t name_type_mask,
BreakpointResolverName::SearchCallback(SearchFilter &filter,
     switch (m_match_type)
     {
         case Breakpoint::Exact:
             if (context.module_sp)
             {
                 for (const LookupInfo &lookup : m_lookups)
                 {
                     const size_t start_func_idx = func_list.GetSize();
+                    const lldb::SymbolRewriterSP rewriter = context.target_sp ? context.target_sp->GetSymbolRewriter() : nullptr;
                     context.module_sp->FindFunctions(lookup.lookup_name,
+                                                     rewriter,
                                                      nullptr,
                                                      lookup.name_type_mask,
                                                      include_symbols,
                                                      include_inlines,
                                                      append,
                                                      func_list);
                     const size_t end_func_idx = func_list.GetSize();
 

source/Commands/CommandObjectSource.cpp

DumpLinesInFunctions (CommandReturnObject &result)
         ConstString name(m_options.symbol_name.c_str());
         SymbolContextList sc_list_lines;
         Target *target = m_exe_ctx.GetTargetPtr();
         uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
 
         // Note: module_list can't be const& because FindFunctionSymbols isn't const.
         ModuleList module_list = (m_module_list.GetSize() > 0) ?
                                  m_module_list : target->GetImages();
         size_t num_matches = module_list.FindFunctions(name,
+                                                       target->GetSymbolRewriter(),
                                                        eFunctionNameTypeAuto,
                                                        /*include_symbols=*/false,
                                                        /*include_inlines=*/true,
                                                        /*append=*/true,
                                                        sc_list_funcs);
         if (!num_matches)
         {
             // If we didn't find any functions with that name, try searching for
             // symbols that line up exactly with function addresses.
             SymbolContextList sc_list_symbols;
             size_t num_symbol_matches = module_list.FindFunctionSymbols(name,
+                                                                        target->GetSymbolRewriter(),
                                                                         eFunctionNameTypeAuto,
                                                                         sc_list_symbols);
             for (size_t i = 0; i < num_symbol_matches; i++)
             {
                 SymbolContext sc;
                 sc_list_symbols.GetContextAtIndex(i, sc);
                 if (sc.symbol && sc.symbol->ValueIsAddress())
                 {
size_t FindMatchingFunctions (Target *target, const ConstString &name, SymbolContextList& sc_list)
             for (size_t i = 0; i < num_modules; ++i)
             {
                 FileSpec module_file_spec(m_options.modules[i].c_str(), false);
                 if (module_file_spec)
                 {
                     ModuleSpec module_spec (module_file_spec);
                     matching_modules.Clear();
                     target->GetImages().FindModules (module_spec, matching_modules);
-                    num_matches += matching_modules.FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
+                    num_matches += matching_modules.FindFunctions (name, target->GetSymbolRewriter(), eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
                 }
             }
         }
         else
         {
-            num_matches = target->GetImages().FindFunctions (name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
+            num_matches = target->GetImages().FindFunctions (name, target->GetSymbolRewriter(), eFunctionNameTypeAuto, include_symbols, include_inlines, append, sc_list);
         }
         return num_matches;
     }
 
     size_t FindMatchingFunctionSymbols (Target *target, const ConstString &name, SymbolContextList& sc_list)
     {
         size_t num_matches = 0;
         const size_t num_modules = m_options.modules.size();
         if (num_modules > 0)
         {
             ModuleList matching_modules;
             for (size_t i = 0; i < num_modules; ++i)
             {
                 FileSpec module_file_spec(m_options.modules[i].c_str(), false);
                 if (module_file_spec)
                 {
                     ModuleSpec module_spec (module_file_spec);
                     matching_modules.Clear();
                     target->GetImages().FindModules (module_spec, matching_modules);
-                    num_matches += matching_modules.FindFunctionSymbols (name, eFunctionNameTypeAuto, sc_list);
+                    num_matches += matching_modules.FindFunctionSymbols (name, target->GetSymbolRewriter(), eFunctionNameTypeAuto, sc_list);
                 }
             }
         }
         else
         {
-            num_matches = target->GetImages().FindFunctionSymbols (name, eFunctionNameTypeAuto, sc_list);
+            num_matches = target->GetImages().FindFunctionSymbols (name, target->GetSymbolRewriter(), eFunctionNameTypeAuto, sc_list);
         }
         return num_matches;
     }
 
     bool
     DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();

source/Commands/CommandObjectTarget.cpp

 #include "lldb/Interpreter/OptionGroupUUID.h"
 #include "lldb/Interpreter/OptionGroupString.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Symbol/SymbolRewriter.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
if (module && name && name[0])
                                                  include_symbols,
                                                  include_inlines, 
                                                  append, 
                                                  sc_list);
         }
         else
         {
             ConstString function_name (name);
+            Target *target = interpreter.GetExecutionContext().GetTargetPtr();
+            const lldb::SymbolRewriterSP rewriter = target ? target->GetSymbolRewriter() : nullptr;
             num_matches = module->FindFunctions(function_name,
+                                                rewriter,
                                                 nullptr,
                                                 eFunctionNameTypeAuto,
                                                 include_symbols,
                                                 include_inlines,
                                                 append, 
                                                 sc_list);
         }
 
DoExecute (Args& command, CommandReturnObject &result) override
             return false;
         }
 
         SymbolContextList sc_list;
 
         if (m_options.m_type == eLookupTypeFunctionOrSymbol)
         {
             ConstString function_name (m_options.m_str.c_str());
-            target->GetImages().FindFunctions (function_name, eFunctionNameTypeAuto, true, false, true, sc_list);
+            target->GetImages().FindFunctions (function_name, target->GetSymbolRewriter(), eFunctionNameTypeAuto, true, false, true, sc_list);
         }
         else if (m_options.m_type == eLookupTypeAddress && target)
         {
             Address addr;
             if (target->GetSectionLoadList().ResolveLoadAddress (m_options.m_addr, addr))
             {
                 SymbolContext sc;
                 ModuleSP module_sp (addr.GetModule());
protected:
     }
 
     OptionGroupOptions m_option_group;
     OptionGroupUUID m_uuid_option_group;
     OptionGroupFile m_file_option;
     OptionGroupBoolean m_current_frame_option;
 };
 
+class CommandObjectTargetSymbolsRewrite : public CommandObjectParsed
+{
+public:
+    CommandObjectTargetSymbolsRewrite (CommandInterpreter &interpreter) :
+        CommandObjectParsed (interpreter,
+                             "target symbols rewrite",
+                             "Add a symbol rewrite file to the target by specifying a path to a rewrite map file.",
+                             "target symbols rewrite [<rewrite_map>]", eCommandRequiresTarget) {}
+
+protected:
+    virtual bool
+    DoExecute (Args& args,
+               CommandReturnObject &result)
+    {
+        Target *target = m_exe_ctx.GetTargetPtr();
+        const char *path = args.GetArgumentAtIndex(0);
+
+        if (!path)
+        {
+            result.AppendMessageWithFormat ("A symbol file path must be provided\n");
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        FileSpec fspec;
+        fspec.SetFile (path, true);
+
+        if (!fspec.Exists())
+        {
+            result.AppendMessageWithFormat ("%s: File not found\n", path);
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+        target->GetSymbolRewriter()->LoadMap (fspec);
+
+        result.SetStatus (eReturnStatusSuccessFinishResult);
+        return true;
+    }
+};
+
 #pragma mark CommandObjectTargetSymbols
 
 //-------------------------------------------------------------------------
 // CommandObjectTargetSymbols
 //-------------------------------------------------------------------------
 
 class CommandObjectTargetSymbols : public CommandObjectMultiword
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     CommandObjectTargetSymbols(CommandInterpreter &interpreter) :
         CommandObjectMultiword (interpreter,
                             "target symbols",
                             "A set of commands for adding and managing debug symbol files.",
                             "target symbols <sub-command> ...")
     {
         LoadSubCommand ("add", CommandObjectSP (new CommandObjectTargetSymbolsAdd (interpreter)));
+        LoadSubCommand ("rewrite", CommandObjectSP (new CommandObjectTargetSymbolsRewrite (interpreter)));
     }
 
     ~CommandObjectTargetSymbols() override = default;
 
 private:
     //------------------------------------------------------------------
     // For CommandObjectTargetModules only
     //------------------------------------------------------------------

source/Core/AddressResolverName.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 AddressResolverName::AddressResolverName(const char *func_name,
                                          AddressResolver::MatchType type) :
     AddressResolver(),
     m_func_name(func_name),
AddressResolverName::SearchCallback(SearchFilter &filter,
     const bool include_symbols = false;
     const bool include_inlines = true;
     const bool append = false;
     switch (m_match_type)
     {
     case AddressResolver::Exact:
         if (context.module_sp)
         {
+            const lldb::SymbolRewriterSP rewriter = context.target_sp ? context.target_sp->GetSymbolRewriter() : nullptr;
             context.module_sp->FindSymbolsWithNameAndType (m_func_name,
+                                                           rewriter,
                                                            eSymbolTypeCode, 
                                                            sym_list);
             context.module_sp->FindFunctions(m_func_name,
+                                             rewriter,
                                              nullptr,
                                              eFunctionNameTypeAuto,
                                              include_symbols,
                                              include_inlines,
                                              append,
                                              func_list);
         }
         break;

source/Core/Disassembler.cpp

Disassembler::Disassemble(Debugger &debugger,
                           uint32_t options,
                           Stream &strm)
 {
     SymbolContextList sc_list;
     if (name)
     {
         const bool include_symbols = true;
         const bool include_inlines = true;
+        Target *target = exe_ctx.GetTargetPtr();
+        const lldb::SymbolRewriterSP rewriter = target ? target->GetSymbolRewriter() : nullptr;
         if (module)
         {
             module->FindFunctions(name,
+                                  rewriter,
                                   nullptr,
                                   eFunctionNameTypeAuto,
                                   include_symbols,
                                   include_inlines,
                                   true,
                                   sc_list);
         }
         else if (exe_ctx.GetTargetPtr())
         {
             exe_ctx.GetTargetPtr()->GetImages().FindFunctions (name, 
+                                                               rewriter,
                                                                eFunctionNameTypeAuto,
                                                                include_symbols,
                                                                include_inlines,
                                                                false,
                                                                sc_list);
         }
     }
     

source/Core/Module.cpp

for (size_t i = 0; i < num_compile_units; ++i)
                 sc_list.Append(sc);
         }
     }
     return sc_list.GetSize() - start_size;
 }
 
 size_t
 Module::FindFunctions (const ConstString &name,
+                       const lldb::SymbolRewriterSP rewriter,
                        const CompilerDeclContext *parent_decl_ctx,
                        uint32_t name_type_mask,
                        bool include_symbols,
                        bool include_inlines,
                        bool append, 
                        SymbolContextList& sc_list)
 {
     if (!append)
if (name_type_mask & eFunctionNameTypeAuto)
                                    append,
                                    sc_list);
         
             // Now check our symbol table for symbols that are code symbols if requested
             if (include_symbols)
             {
                 Symtab *symtab = symbols->GetSymtab();
                 if (symtab)
-                    symtab->FindFunctionSymbols(lookup_name, lookup_name_type_mask, sc_list);
+                    symtab->FindFunctionSymbols(lookup_name, rewriter, lookup_name_type_mask, sc_list);
             }
         }
 
         if (match_name_after_lookup)
         {
             SymbolContext sc;
             size_t i = old_size;
             while (i < sc_list.GetSize())
else
         {
             symbols->FindFunctions(name, parent_decl_ctx, name_type_mask, include_inlines, append, sc_list);
 
             // Now check our symbol table for symbols that are code symbols if requested
             if (include_symbols)
             {
                 Symtab *symtab = symbols->GetSymtab();
                 if (symtab)
-                    symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
+                    symtab->FindFunctionSymbols(name, rewriter, name_type_mask, sc_list);
             }
         }
     }
 
     return sc_list.GetSize() - old_size;
 }
 
 size_t

 {
     // Populate m_unified_sections_ap with sections from objfile.
     if (!m_sections_ap)
         m_sections_ap.reset(new SectionList());
     return m_sections_ap.get();
 }
 
 const Symbol *
-Module::FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type)
+Module::FindFirstSymbolWithNameAndType (const ConstString &name, const lldb::SymbolRewriterSP rewriter, SymbolType symbol_type)
 {
     Timer scoped_timer(__PRETTY_FUNCTION__,
                        "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
                        name.AsCString(),
                        symbol_type);
     SymbolVendor* sym_vendor = GetSymbolVendor();
     if (sym_vendor)
     {
         Symtab *symtab = sym_vendor->GetSymtab();
         if (symtab)
-            return symtab->FindFirstSymbolWithNameAndType (name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
+            return symtab->FindFirstSymbolWithNameAndType (name, rewriter, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
     }
     return nullptr;
 }
 void
 Module::SymbolIndicesToSymbolContextList (Symtab *symtab, std::vector<uint32_t> &symbol_indexes, SymbolContextList &sc_list)
 {
     // No need to protect this call using m_mutex all other method calls are
     // already thread safe.
if (num_indices > 0)
             if (sc.symbol)
                 sc_list.Append (sc);
         }
     }
 }
 
 size_t
 Module::FindFunctionSymbols (const ConstString &name,
+                             const lldb::SymbolRewriterSP rewriter,
                              uint32_t name_type_mask,
                              SymbolContextList& sc_list)
 {
     Timer scoped_timer(__PRETTY_FUNCTION__,
                        "Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
                        name.AsCString(),
                        name_type_mask);
     SymbolVendor* sym_vendor = GetSymbolVendor();
     if (sym_vendor)
     {
         Symtab *symtab = sym_vendor->GetSymtab();
         if (symtab)
-            return symtab->FindFunctionSymbols (name, name_type_mask, sc_list);
+            return symtab->FindFunctionSymbols (name, rewriter, name_type_mask, sc_list);
     }
     return 0;
 }
 
 size_t
-Module::FindSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, SymbolContextList &sc_list)
+Module::FindSymbolsWithNameAndType (const ConstString &name, const lldb::SymbolRewriterSP rewriter, SymbolType symbol_type, SymbolContextList &sc_list)
 {
     // No need to protect this call using m_mutex all other method calls are
     // already thread safe.
 
     Timer scoped_timer(__PRETTY_FUNCTION__,
                        "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
                        name.AsCString(),
                        symbol_type);
     const size_t initial_size = sc_list.GetSize();
     SymbolVendor* sym_vendor = GetSymbolVendor();
     if (sym_vendor)
     {
         Symtab *symtab = sym_vendor->GetSymtab();
         if (symtab)
         {
             std::vector<uint32_t> symbol_indexes;
-            symtab->FindAllSymbolsWithNameAndType (name, symbol_type, symbol_indexes);
+            symtab->FindAllSymbolsWithNameAndType (name, rewriter, symbol_type, symbol_indexes);
             SymbolIndicesToSymbolContextList (symtab, symbol_indexes, sc_list);
         }
     }
     return sc_list.GetSize() - initial_size;
 }
 
 size_t
 Module::FindSymbolsMatchingRegExAndType (const RegularExpression &regex, SymbolType symbol_type, SymbolContextList &sc_list)

source/Core/ModuleList.cpp

ModuleList::GetModuleAtIndexUnlocked(size_t idx) const
     ModuleSP module_sp;
     if (idx < m_modules.size())
         module_sp = m_modules[idx];
     return module_sp;
 }
 
 size_t
 ModuleList::FindFunctions (const ConstString &name, 
+                           const lldb::SymbolRewriterSP rewriter,
                            uint32_t name_type_mask, 
                            bool include_symbols,
                            bool include_inlines,
                            bool append, 
                            SymbolContextList &sc_list) const
 {
     if (!append)
         sc_list.Clear();
if (name_type_mask & eFunctionNameTypeAuto)
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
 
         std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
             (*pos)->FindFunctions(lookup_name,
+                                  rewriter,
                                   nullptr,
                                   lookup_name_type_mask,
                                   include_symbols,
                                   include_inlines,
                                   true,
                                   sc_list);
         }
         
if (name_type_mask & eFunctionNameTypeAuto)
         }
     }
     else
     {
         std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
-            (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols, include_inlines, true, sc_list);
+            (*pos)->FindFunctions(name, rewriter, nullptr, name_type_mask, include_symbols, include_inlines, true, sc_list);
         }
     }
     return sc_list.GetSize() - old_size;
 }
 
 size_t
 ModuleList::FindFunctionSymbols (const ConstString &name,
+                                 const lldb::SymbolRewriterSP rewriter,
                                  uint32_t name_type_mask,
                                  SymbolContextList& sc_list)
 {
     const size_t old_size = sc_list.GetSize();
 
     if (name_type_mask & eFunctionNameTypeAuto)
     {
         ConstString lookup_name;
         uint32_t lookup_name_type_mask = 0;
         bool match_name_after_lookup = false;
         Module::PrepareForFunctionNameLookup (name, name_type_mask,
                                               eLanguageTypeUnknown, // TODO: add support
                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
 
         std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
             (*pos)->FindFunctionSymbols (lookup_name,
+                                         rewriter,
                                          lookup_name_type_mask,
                                          sc_list);
         }
         
         if (match_name_after_lookup)
         {
             SymbolContext sc;
             size_t i = old_size;
             while (i < sc_list.GetSize())
             {
if (name_type_mask & eFunctionNameTypeAuto)
         }
     }
     else
     {
         std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
-            (*pos)->FindFunctionSymbols (name, name_type_mask, sc_list);
+            (*pos)->FindFunctionSymbols (name, rewriter, name_type_mask, sc_list);
         }
     }
 
     return sc_list.GetSize() - old_size;
 }
 
 size_t
 ModuleList::FindFunctions(const RegularExpression &name,
ModuleList::FindGlobalVariables (const RegularExpression& regex,
     {
         (*pos)->FindGlobalVariables (regex, append, max_matches, variable_list);
     }
     return variable_list.GetSize() - initial_size;
 }
 
 size_t
 ModuleList::FindSymbolsWithNameAndType (const ConstString &name, 
+                                        const lldb::SymbolRewriterSP rewriter,
                                         SymbolType symbol_type, 
                                         SymbolContextList &sc_list,
                                         bool append) const
 {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     if (!append)
         sc_list.Clear();
     size_t initial_size = sc_list.GetSize();
     
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
-        (*pos)->FindSymbolsWithNameAndType (name, symbol_type, sc_list);
+        (*pos)->FindSymbolsWithNameAndType (name, rewriter, symbol_type, sc_list);
     return sc_list.GetSize() - initial_size;
 }
 
 size_t
 ModuleList::FindSymbolsMatchingRegExAndType (const RegularExpression &regex, 
                                              lldb::SymbolType symbol_type, 
                                              SymbolContextList &sc_list,
                                              bool append) const

source/Core/SourceManager.cpp

else if (!m_default_set)
             if (executable_ptr)
             {
                 SymbolContextList sc_list;
                 ConstString main_name("main");
                 bool symbols_okay = false;  // Force it to be a debug symbol.
                 bool inlines_okay = true;
                 bool append = false;
                 size_t num_matches = executable_ptr->FindFunctions (main_name,
+                                                                    target_sp->GetSymbolRewriter(),
                                                                     NULL,
                                                                     lldb::eFunctionNameTypeBase,
                                                                     inlines_okay,
                                                                     symbols_okay,
                                                                     append,
                                                                     sc_list);
                 for (size_t idx = 0; idx < num_matches; idx++)
                 {

source/Expression/IRExecutionUnit.cpp

for (const SearchSpec &spec : specs)
             }
 
             return false;
         };
 
         if (sc.module_sp)
         {
             sc.module_sp->FindFunctions(spec.name,
+                                        target->GetSymbolRewriter(),
                                         NULL,
                                         spec.mask,
                                         true,  // include_symbols
                                         false, // include_inlines
                                         true,  // append
                                         sc_list);
         }
 
         lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 
         if (get_external_load_address(load_address, sc_list, sc))
         {
             return load_address;
         }
         else
         {
             sc_list.Clear();
         }
 
         if (sc_list.GetSize() == 0 && sc.target_sp)
         {
             sc.target_sp->GetImages().FindFunctions(spec.name,
+                                                    target->GetSymbolRewriter(),
                                                     spec.mask,
                                                     true,  // include_symbols
                                                     false, // include_inlines
                                                     true,  // append
                                                     sc_list);
         }
 
         if (get_external_load_address(load_address, sc_list, sc))
         {
             return load_address;
         }
         else
         {
             sc_list.Clear();
         }
 
         if (sc_list.GetSize() == 0 && sc.target_sp)
         {
-            sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, lldb::eSymbolTypeAny, sc_list);
+            sc.target_sp->GetImages().FindSymbolsWithNameAndType(spec.name, sc.target_sp->GetSymbolRewriter(), lldb::eSymbolTypeAny, sc_list);
         }
 
         if (get_external_load_address(load_address, sc_list, sc))
         {
             return load_address;
         }
         // if there are any searches we try after this, add an sc_list.Clear() in an "else" clause here
 

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 // calls to this function should return false after the kernel has been
 // already loaded).
 //----------------------------------------------------------------------
 void
 DynamicLoaderDarwinKernel::LoadKernelModuleIfNeeded()
 {
     if (!m_kext_summary_header_ptr_addr.IsValid())
     {
+        Target &target = m_process->GetTarget();
+
         m_kernel.Clear();
-        m_kernel.SetModule (m_process->GetTarget().GetExecutableModule());
+        m_kernel.SetModule (target.GetExecutableModule());
         m_kernel.SetIsKernel(true);
 
         ConstString kernel_name("mach_kernel");
         if (m_kernel.GetModule().get()
             && m_kernel.GetModule()->GetObjectFile()
             && !m_kernel.GetModule()->GetObjectFile()->GetFileSpec().GetFilename().IsEmpty())
         {
             kernel_name = m_kernel.GetModule()->GetObjectFile()->GetFileSpec().GetFilename();
         }
         m_kernel.SetName (kernel_name.AsCString());
 
         if (m_kernel.GetLoadAddress() == LLDB_INVALID_ADDRESS)
         {
             m_kernel.SetLoadAddress(m_kernel_load_address);
             if (m_kernel.GetLoadAddress() == LLDB_INVALID_ADDRESS && m_kernel.GetModule())
             {
                 // We didn't get a hint from the process, so we will
                 // try the kernel at the address that it exists at in
                 // the file if we have one
                 ObjectFile *kernel_object_file = m_kernel.GetModule()->GetObjectFile();
                 if (kernel_object_file)
                 {
-                    addr_t load_address = kernel_object_file->GetHeaderAddress().GetLoadAddress(&m_process->GetTarget());
+                    addr_t load_address = kernel_object_file->GetHeaderAddress().GetLoadAddress(&target);
                     addr_t file_address = kernel_object_file->GetHeaderAddress().GetFileAddress();
                     if (load_address != LLDB_INVALID_ADDRESS && load_address != 0)
                     {
                         m_kernel.SetLoadAddress (load_address);
                         if (load_address != file_address)
                         {
                             // Don't accidentally relocate the kernel to the File address -- 
                             // the Load address has already been set to its actual in-memory address.  
if (!m_kext_summary_header_ptr_addr.IsValid())
             {
                 m_kernel.LoadImageAtFileAddress (m_process);
             }
         }
 
         if (m_kernel.IsLoaded() && m_kernel.GetModule())
         {
             static ConstString kext_summary_symbol ("gLoadedKextSummaries");
-            const Symbol *symbol = m_kernel.GetModule()->FindFirstSymbolWithNameAndType (kext_summary_symbol, eSymbolTypeData);
+            const Symbol *symbol = m_kernel.GetModule()->FindFirstSymbolWithNameAndType (kext_summary_symbol, target.GetSymbolRewriter(), eSymbolTypeData);
             if (symbol)
             {
                 m_kext_summary_header_ptr_addr = symbol->GetAddress();
                 // Update all image infos
                 ReadAllKextSummaries ();
             }
         }
         else

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
     const ConstString sym_name = sym->GetMangled().GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
     if (!sym_name)
         return thread_plan_sp;
 
     SymbolContextList target_symbols;
     Target &target = thread.GetProcess()->GetTarget();
     const ModuleList &images = target.GetImages();
 
-    images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
+    images.FindSymbolsWithNameAndType(sym_name, target.GetSymbolRewriter(), eSymbolTypeCode, target_symbols);
     size_t num_targets = target_symbols.GetSize();
     if (!num_targets)
         return thread_plan_sp;
 
     typedef std::vector<lldb::addr_t> AddressVector;
     AddressVector addrs;
     for (size_t i = 0; i < num_targets; ++i)
     {

source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.cpp

 }
 
 bool
 HexagonDYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {
     Target& target = m_process->GetTarget();
 
     SymbolContextList list;
-    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), eSymbolTypeAny, list))
+    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), target.GetSymbolRewriter(), eSymbolTypeAny, list))
         return false;
 
     Address address = list[0].symbol->GetAddress();
     addr_t addr = address.GetLoadAddress (&target);
     if (addr == LLDB_INVALID_ADDRESS)
         return false;
 
     Error error;

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (ReadMachHeader (addr, &m_dyld.header, &data))
                 }
             }
 
             Target &target = m_process->GetTarget();
 
             if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS && dyld_module_sp.get())
             {
                 static ConstString g_dyld_all_image_infos ("dyld_all_image_infos");
-                const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType (g_dyld_all_image_infos, eSymbolTypeData);
+                const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType (g_dyld_all_image_infos, target.GetSymbolRewriter(), eSymbolTypeData);
                 if (symbol)
                     m_dyld_all_image_infos_addr = symbol->GetLoadAddress(&target);
             }
 
             // Update all image infos
             InitializeFromAllImageInfos ();
 
             // If we didn't have an executable before, but now we do, then the
if (current_symbol != NULL)
         {
             const ConstString &trampoline_name = current_symbol->GetMangled().GetName(current_symbol->GetLanguage(), Mangled::ePreferMangled);
             
             if (trampoline_name)
             {
                 const ModuleList &images = target_sp->GetImages();
                 
                 SymbolContextList code_symbols;
-                images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode, code_symbols);
+                images.FindSymbolsWithNameAndType(trampoline_name, target_sp->GetSymbolRewriter(), eSymbolTypeCode, code_symbols);
                 size_t num_code_symbols = code_symbols.GetSize();
                 
                 if (num_code_symbols > 0)
                 {
                     for (uint32_t i = 0; i < num_code_symbols; i++)
                     {
                         SymbolContext context;
                         AddressRange addr_range;
                         if (code_symbols.GetContextAtIndex(i, context))
                         {
                             context.GetAddressRange (eSymbolContextEverything, 0, false, addr_range);
                             addresses.push_back(addr_range.GetBaseAddress());
                             if (log)
                             {
                                 addr_t load_addr = addr_range.GetBaseAddress().GetLoadAddress(target_sp.get());
 
                                 log->Printf ("Found a trampoline target symbol at 0x%" PRIx64 ".", load_addr);
                             }
                         }
                     }
                 }
                 
                 SymbolContextList reexported_symbols;
-                images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeReExported, reexported_symbols);
+                images.FindSymbolsWithNameAndType(trampoline_name, target_sp->GetSymbolRewriter(), eSymbolTypeReExported, reexported_symbols);
                 size_t num_reexported_symbols = reexported_symbols.GetSize();
                 if (num_reexported_symbols > 0)
                 {
                     for (uint32_t i = 0; i < num_reexported_symbols; i++)
                     {
                         SymbolContext context;
                         if (reexported_symbols.GetContextAtIndex(i, context))
                         {
if (current_symbol != NULL)
                                     }
                                 }
                             }
                         }
                     }
                 }
                 
                 SymbolContextList indirect_symbols;
-                images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeResolver, indirect_symbols);
+                images.FindSymbolsWithNameAndType(trampoline_name, target_sp->GetSymbolRewriter(), eSymbolTypeResolver, indirect_symbols);
                 size_t num_indirect_symbols = indirect_symbols.GetSize();
                 if (num_indirect_symbols > 0)
                 {
                     for (uint32_t i = 0; i < num_indirect_symbols; i++)
                     {
                         SymbolContext context;
                         AddressRange addr_range;
                         if (indirect_symbols.GetContextAtIndex(i, context))

 DynamicLoaderMacOSXDYLD::GetPthreadSetSpecificAddress()
 {
     if (!m_pthread_getspecific_addr.IsValid())
     {
         ModuleSP module_sp = GetPThreadLibraryModule();
         if (module_sp)
         {
             lldb_private::SymbolContextList sc_list;
-            module_sp->FindSymbolsWithNameAndType(ConstString("pthread_getspecific"), eSymbolTypeCode, sc_list);
+            module_sp->FindSymbolsWithNameAndType(ConstString("pthread_getspecific"), m_process->GetTarget().GetSymbolRewriter(), eSymbolTypeCode, sc_list);
             SymbolContext sc;
             if (sc_list.GetContextAtIndex(0, sc))
             {
                 if (sc.symbol)
                     m_pthread_getspecific_addr = sc.symbol->GetAddress();
             }
         }
     }

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

 
 
 bool
 DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {
     Target& target = m_process->GetTarget();
 
     SymbolContextList list;
-    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), eSymbolTypeAny, list))
+    if (!target.GetImages().FindSymbolsWithNameAndType (ConstString(name), target.GetSymbolRewriter(), eSymbolTypeAny, list))
         return false;
 
     Address address = list[0].symbol->GetAddress();
     addr_t addr = address.GetLoadAddress (&target);
     if (addr == LLDB_INVALID_ADDRESS)
         return false;
 
     Error error;

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
     ConstString sym_name = sym->GetName();
     if (!sym_name)
         return thread_plan_sp;
 
     SymbolContextList target_symbols;
     Target &target = thread.GetProcess()->GetTarget();
     const ModuleList &images = target.GetImages();
 
-    images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
+    images.FindSymbolsWithNameAndType(sym_name, target.GetSymbolRewriter(), eSymbolTypeCode, target_symbols);
     size_t num_targets = target_symbols.GetSize();
     if (!num_targets)
         return thread_plan_sp;
 
     typedef std::vector<lldb::addr_t> AddressVector;
     AddressVector addrs;
     for (size_t i = 0; i < num_targets; ++i)
     {

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

ClangASTSource::FindObjCMethodDecls (NameSearchContext &context)
 
     do
     {
         StreamString ms;
         ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString());
         ms.Flush();
         ConstString instance_method_name(ms.GetData());
 
-        m_target->GetImages().FindFunctions(instance_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
+        const lldb::SymbolRewriterSP rewriter = m_target->GetSymbolRewriter();
+
+        m_target->GetImages().FindFunctions(instance_method_name, rewriter, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
 
         if (sc_list.GetSize())
             break;
 
         ms.Clear();
         ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString());
         ms.Flush();
         ConstString class_method_name(ms.GetData());
 
-        m_target->GetImages().FindFunctions(class_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
+        m_target->GetImages().FindFunctions(class_method_name, rewriter, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, append, sc_list);
 
         if (sc_list.GetSize())
             break;
 
         // Fall back and check for methods in categories.  If we find methods this way, we need to check that they're actually in
         // categories on the desired class.
 
         SymbolContextList candidate_sc_list;
 
-        m_target->GetImages().FindFunctions(selector_name, lldb::eFunctionNameTypeSelector, include_symbols, include_inlines, append, candidate_sc_list);
+        m_target->GetImages().FindFunctions(selector_name, rewriter, lldb::eFunctionNameTypeSelector, include_symbols, include_inlines, append, candidate_sc_list);
 
         for (uint32_t ci = 0, ce = candidate_sc_list.GetSize();
              ci != ce;
              ++ci)
         {
             SymbolContext candidate_sc;
 
             if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc))

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

ClangExpressionDeclMap::GetSymbolAddress (Target &target,
                                           Process *process,
                                           const ConstString &name,
                                           lldb::SymbolType symbol_type,
                                           lldb_private::Module *module)
 {
     SymbolContextList sc_list;
 
     if (module)
-        module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
+        module->FindSymbolsWithNameAndType(name, target.GetSymbolRewriter(), symbol_type, sc_list);
     else
-        target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
+        target.GetImages().FindSymbolsWithNameAndType(name, target.GetSymbolRewriter(), symbol_type, sc_list);
 
     const uint32_t num_matches = sc_list.GetSize();
     addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
 
     for (uint32_t i=0; i<num_matches && (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS); i++)
     {
         SymbolContext sym_ctx;
         sc_list.GetContextAtIndex(i, sym_ctx);

 const Symbol *
 ClangExpressionDeclMap::FindGlobalDataSymbol (Target &target,
                                               const ConstString &name,
                                               lldb_private::Module *module)
 {
     SymbolContextList sc_list;
 
     if (module)
-        module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
+        module->FindSymbolsWithNameAndType(name, target.GetSymbolRewriter(), eSymbolTypeAny, sc_list);
     else
-        target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
+        target.GetImages().FindSymbolsWithNameAndType(name, target.GetSymbolRewriter(), eSymbolTypeAny, sc_list);
 
     const uint32_t matches = sc_list.GetSize();
     for (uint32_t i=0; i<matches; ++i)
     {
         SymbolContext sym_ctx;
         sc_list.GetContextAtIndex(i, sym_ctx);
         if (sym_ctx.symbol)
         {
else
             }
         }
 
         if (!context.m_found.variable)
         {
             const bool include_inlines = false;
             const bool append = false;
 
+            const lldb::SymbolRewriterSP rewriter = target ? target->GetSymbolRewriter() : nullptr;
             if (namespace_decl && module_sp)
             {
                 const bool include_symbols = false;
 
                 module_sp->FindFunctions(name,
+                                         rewriter,
                                          &namespace_decl,
                                          eFunctionNameTypeBase,
                                          include_symbols,
                                          include_inlines,
                                          append,
                                          sc_list);
             }
             else if (target && !namespace_decl)
             {
                 const bool include_symbols = true;
 
                 // TODO Fix FindFunctions so that it doesn't return
                 //   instance methods for eFunctionNameTypeBase.
 
                 target->GetImages().FindFunctions(name,
+                                                  rewriter,
                                                   eFunctionNameTypeFull,
                                                   include_symbols,
                                                   include_inlines,
                                                   append,
                                                   sc_list);
             }
 
             // If we found more than one function, see if we can use the

source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

if (process_sp)
         m_process_wp = process_sp;
 }
 
 AddressSanitizerRuntime::~AddressSanitizerRuntime()
 {
     Deactivate();
 }
 
-bool ModuleContainsASanRuntime(Module * module)
+bool ModuleContainsASanRuntime(Module * module, const lldb::SymbolRewriterSP rewriter)
 {
     const Symbol* symbol = module->FindFirstSymbolWithNameAndType(
             ConstString("__asan_get_alloc_stack"),
+            rewriter,
             lldb::eSymbolTypeAny);
 
     return symbol != nullptr;
 }
 
 void
 AddressSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
 {
for (size_t i = 0; i < num_modules; ++i)
         Module *module_pointer = module_list.GetModulePointerAtIndexUnlocked(i);
         const FileSpec & file_spec = module_pointer->GetFileSpec();
         if (! file_spec)
             continue;
         
         static RegularExpression g_asan_runtime_regex("libclang_rt.asan_(.*)_dynamic\\.dylib");
         if (g_asan_runtime_regex.Execute (file_spec.GetFilename().GetCString()) || module_pointer->IsExecutable())
         {
-            if (ModuleContainsASanRuntime(module_pointer))
+            ProcessSP process_sp = GetProcessSP();
+            const lldb::SymbolRewriterSP rewriter = process_sp ? process_sp->GetTarget().GetSymbolRewriter() : nullptr;
+            if (ModuleContainsASanRuntime(module_pointer, rewriter))
             {
                 m_runtime_module = module_pointer->shared_from_this();
                 Activate();
                 return;
             }
         }
     }
 }
AddressSanitizerRuntime::Activate()
     if (m_is_active)
         return;
 
     ProcessSP process_sp = GetProcessSP();
     if (!process_sp)
         return;
 
     ConstString symbol_name ("__asan::AsanDie()");
-    const Symbol *symbol = m_runtime_module->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
+    const Symbol *symbol = m_runtime_module->FindFirstSymbolWithNameAndType (symbol_name, process_sp->GetTarget().GetSymbolRewriter(), eSymbolTypeCode);
     
     if (symbol == NULL)
         return;
     
     if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
         return;
     
     Target &target = process_sp->GetTarget();

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

 }
 
 ThreadSanitizerRuntime::~ThreadSanitizerRuntime()
 {
     Deactivate();
 }
 
 static bool
-ModuleContainsTSanRuntime(ModuleSP module_sp)
+ModuleContainsTSanRuntime(ModuleSP module_sp, const lldb::SymbolRewriterSP rewriter)
 {
     static ConstString g_tsan_get_current_report("__tsan_get_current_report");
-    const Symbol* symbol = module_sp->FindFirstSymbolWithNameAndType(g_tsan_get_current_report, lldb::eSymbolTypeAny);
+    const Symbol* symbol = module_sp->FindFirstSymbolWithNameAndType(g_tsan_get_current_report, rewriter, lldb::eSymbolTypeAny);
     return symbol != nullptr;
 }
 
 void
 ThreadSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
 {
     if (IsActive())
         return;
     
     if (GetRuntimeModuleSP()) {
         Activate();
         return;
     }
     
     module_list.ForEach ([this](const lldb::ModuleSP module_sp) -> bool
     {
         const FileSpec & file_spec = module_sp->GetFileSpec();
         if (! file_spec)
             return true; // Keep iterating through modules
         
         llvm::StringRef module_basename(file_spec.GetFilename().GetStringRef());
         if (module_sp->IsExecutable() || module_basename.startswith("libclang_rt.tsan_"))
         {
-            if (ModuleContainsTSanRuntime(module_sp))
+            ProcessSP process_sp = GetProcessSP();
+            const lldb::SymbolRewriterSP rewriter = process_sp ? process_sp->GetTarget().GetSymbolRewriter() : nullptr;
+            if (ModuleContainsTSanRuntime(module_sp, rewriter))
             {
                 m_runtime_module_wp = module_sp;
                 Activate();
                 return false; // Stop iterating
             }
         }
 
         return true; // Keep iterating through modules
ThreadSanitizerRuntime::Activate()
     if (m_is_active)
         return;
     
     ProcessSP process_sp = GetProcessSP();
     if (!process_sp)
         return;
     
     ConstString symbol_name ("__tsan_on_report");
-    const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
+    const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType (symbol_name, process_sp->GetTarget().GetSymbolRewriter(), eSymbolTypeCode);
     
     if (symbol == NULL)
         return;
     
     if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
         return;
     
     Target &target = process_sp->GetTarget();

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 
 addr_t
 JITLoaderGDB::GetSymbolAddress(ModuleList &module_list, const ConstString &name,
                                SymbolType symbol_type) const
 {
     SymbolContextList target_symbols;
     Target &target = m_process->GetTarget();
 
-    if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
-                                                target_symbols))
+    if (!module_list.FindSymbolsWithNameAndType(name, target.GetSymbolRewriter(),
+                                                symbol_type, target_symbols))
         return LLDB_INVALID_ADDRESS;
 
     SymbolContext sym_ctx;
     target_symbols.GetContextAtIndex(0, sym_ctx);
 
     const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress();
     if (!jit_descriptor_addr.IsValid())
         return LLDB_INVALID_ADDRESS;
 
     const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target);
     return jit_addr;
 }

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp

AppleObjCRuntime::GetObjCModule ()
     return ModuleSP();
 }
 
 Address *
 AppleObjCRuntime::GetPrintForDebuggerAddr()
 {
     if (!m_PrintForDebugger_addr.get())
     {
-        const ModuleList &modules = m_process->GetTarget().GetImages();
+        Target &target = m_process->GetTarget();
+        const ModuleList &modules = target.GetImages();
         
         SymbolContextList contexts;
         SymbolContext context;
         
-        if ((!modules.FindSymbolsWithNameAndType(ConstString ("_NSPrintForDebugger"), eSymbolTypeCode, contexts)) &&
-           (!modules.FindSymbolsWithNameAndType(ConstString ("_CFPrintForDebugger"), eSymbolTypeCode, contexts)))
+        if ((!modules.FindSymbolsWithNameAndType(ConstString ("_NSPrintForDebugger"), target.GetSymbolRewriter(), eSymbolTypeCode, contexts)) &&
+           (!modules.FindSymbolsWithNameAndType(ConstString ("_CFPrintForDebugger"), target.GetSymbolRewriter(), eSymbolTypeCode, contexts)))
             return NULL;
         
         contexts.GetContextAtIndex(0, context);
         
         m_PrintForDebugger_addr.reset(new Address(context.symbol->GetAddress()));
     }
     
     return m_PrintForDebugger_addr.get();

 
 bool
 AppleObjCRuntime::AppleIsModuleObjCLibrary (const ModuleSP &module_sp)
 {
     if (module_sp)
     {
         const FileSpec &module_file_spec = module_sp->GetFileSpec();
         static ConstString ObjCName ("libobjc.A.dylib");
-        
         if (module_file_spec)
         {
             if (module_file_spec.GetFilename() == ObjCName)
                 return true;
         }
     }
     return false;
 }
AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing()
     
     Target &target(m_process->GetTarget());
     
     static ConstString s_method_signature("-[NSDictionary objectForKeyedSubscript:]");
     static ConstString s_arclite_method_signature("__arclite_objectForKeyedSubscript");
     
     SymbolContextList sc_list;
     
-    if (target.GetImages().FindSymbolsWithNameAndType(s_method_signature, eSymbolTypeCode, sc_list) ||
-        target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, eSymbolTypeCode, sc_list))
+    if (target.GetImages().FindSymbolsWithNameAndType(s_method_signature, target.GetSymbolRewriter(), eSymbolTypeCode, sc_list) ||
+        target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, target.GetSymbolRewriter(), eSymbolTypeCode, sc_list))
         return true;
     else
         return false;
 }
 
 lldb::SearchFilterSP
 AppleObjCRuntime::CreateExceptionSearchFilter ()
 {

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

AppleObjCRuntimeV1::GetISAHashTablePointer ()
     {
         ModuleSP objc_module_sp(GetObjCModule());
         
         if (!objc_module_sp)
             return LLDB_INVALID_ADDRESS;
         
         static ConstString g_objc_debug_class_hash("_objc_debug_class_hash");
         
-        const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_objc_debug_class_hash, lldb::eSymbolTypeData);
-        if (symbol && symbol->ValueIsAddress())
-        {
-            Process *process = GetProcess();
-            if (process)
-            {
-
+            const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_objc_debug_class_hash, process->GetTarget().GetSymbolRewriter(), lldb::eSymbolTypeData);
+            if (symbol && symbol->ValueIsAddress())
+            {
                 lldb::addr_t objc_debug_class_hash_addr = symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
             
                 if (objc_debug_class_hash_addr != LLDB_INVALID_ADDRESS)
                 {
                     Error error;
                     lldb::addr_t objc_debug_class_hash_ptr = process->ReadPointerFromMemory(objc_debug_class_hash_addr, error);
                     if (objc_debug_class_hash_ptr != 0 &&
                         objc_debug_class_hash_ptr != LLDB_INVALID_ADDRESS)

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

ExtractRuntimeGlobalSymbol (Process* process,
     }
     if (!module_sp)
     {
         error.SetErrorString("no module");
         return default_value;
     }
     if (!byte_size)
         byte_size = process->GetAddressByteSize();
-    const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);
+    const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(name, process->GetTarget().GetSymbolRewriter(), lldb::eSymbolTypeData);
     if (symbol && symbol->ValueIsAddress())
     {
         lldb::addr_t symbol_load_addr = symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
         if (symbol_load_addr != LLDB_INVALID_ADDRESS)
         {
             if (read_value)
                 return process->ReadUnsignedIntegerFromMemory(symbol_load_addr, byte_size, default_value, error);
             else
: AppleObjCRuntime(process),
       m_hash_signature(),
       m_has_object_getClass(false),
       m_loaded_objc_opt(false),
       m_non_pointer_isa_cache_ap(NonPointerISACache::CreateInstance(*this, objc_module_sp)),
       m_tagged_pointer_vendor_ap(TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
       m_encoding_to_type_sp(),
       m_noclasses_warning_emitted(false)
 {
+    const lldb::SymbolRewriterSP rewriter = process ? process->GetTarget().GetSymbolRewriter() : nullptr;
+
     static const ConstString g_gdb_object_getClass("gdb_object_getClass");
     m_has_object_getClass =
-        (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, eSymbolTypeCode) != NULL);
+        (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, rewriter, eSymbolTypeCode) != NULL);
 }
 
 bool
 AppleObjCRuntimeV2::GetDynamicTypeAndAddress (ValueObject &in_value,
                                               DynamicValueType use_dynamic, 
                                               TypeAndOrName &class_type_or_name, 
                                               Address &address,
                                               Value::ValueType &value_type)
if (class_name && class_name[0] && ivar_name && ivar_name[0])
         ConstString ivar_const_str (buffer.c_str());
         
         //----------------------------------------------------------------------
         // Try to get the ivar offset address from the symbol table first using
         // the name we created above
         //----------------------------------------------------------------------
         SymbolContextList sc_list;
         Target &target = m_process->GetTarget();
-        target.GetImages().FindSymbolsWithNameAndType(ivar_const_str, eSymbolTypeObjCIVar, sc_list);
+        target.GetImages().FindSymbolsWithNameAndType(ivar_const_str, target.GetSymbolRewriter(), eSymbolTypeObjCIVar, sc_list);
 
         addr_t ivar_offset_address = LLDB_INVALID_ADDRESS;
 
         Error error;
         SymbolContext ivar_offset_symbol;
         if (sc_list.GetSize() == 1 && sc_list.GetContextAtIndex(0, ivar_offset_symbol))
         {
             if (ivar_offset_symbol.symbol)

 }
 
 lldb::addr_t
 AppleObjCRuntimeV2::GetISAHashTablePointer ()
 {
     if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS)
     {
         Process *process = GetProcess();
+        Target &target = process->GetTarget();
 
         ModuleSP objc_module_sp(GetObjCModule());
         
         if (!objc_module_sp)
             return LLDB_INVALID_ADDRESS;
 
         static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes");
         
-        const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_objc_realized_classes, lldb::eSymbolTypeAny);
+        const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_objc_realized_classes, target.GetSymbolRewriter(), lldb::eSymbolTypeAny);
         if (symbol)
         {
-            lldb::addr_t gdb_objc_realized_classes_ptr = symbol->GetLoadAddress(&process->GetTarget());
+            lldb::addr_t gdb_objc_realized_classes_ptr = symbol->GetLoadAddress(&target);
             
             if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS)
             {
                 Error error;
                 m_isa_hash_table_ptr = process->ReadPointerFromMemory(gdb_objc_realized_classes_ptr, error);
             }
         }
     }

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

if (process_sp)
                 }
             }
         }
         
         if (m_objc_module_sp)
         {
             ConstString trampoline_name ("gdb_objc_trampolines");
             const Symbol *trampoline_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (trampoline_name, 
+                                                                                                target.GetSymbolRewriter(),
                                                                                                 eSymbolTypeData);
             if (trampoline_symbol != NULL)
             {
                 m_trampoline_header = trampoline_symbol->GetLoadAddress(&target);
                 if (m_trampoline_header == LLDB_INVALID_ADDRESS)
                     return false;
                 
                 // Next look up the "changed" symbol and set a breakpoint on that...
                 ConstString changed_name ("gdb_objc_trampolines_changed");
                 const Symbol *changed_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (changed_name, 
+                                                                                                 target.GetSymbolRewriter(),
                                                                                                  eSymbolTypeCode);
                 if (changed_symbol != NULL)
                 {
                     const Address changed_symbol_addr = changed_symbol->GetAddress();
                     if (!changed_symbol_addr.IsValid())
                         return false;
                         
                     lldb::addr_t changed_addr = changed_symbol_addr.GetOpcodeLoadAddress (&target);
AppleObjCTrampolineHandler::AppleObjCTrampolineHandler (const ProcessSP &process_sp,
     // Look up the known resolution functions:
     
     ConstString get_impl_name("class_getMethodImplementation");
     ConstString get_impl_stret_name("class_getMethodImplementation_stret");
     ConstString msg_forward_name("_objc_msgForward");
     ConstString msg_forward_stret_name("_objc_msgForward_stret");
     
     Target *target = process_sp ? &process_sp->GetTarget() : NULL;
-    const Symbol *class_getMethodImplementation = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_name, eSymbolTypeCode);
-    const Symbol *class_getMethodImplementation_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_stret_name, eSymbolTypeCode);
-    const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_name, eSymbolTypeCode);
-    const Symbol *msg_forward_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_stret_name, eSymbolTypeCode);
+    const lldb::SymbolRewriterSP rewriter = target ? target->GetSymbolRewriter() : nullptr;
+    const Symbol *class_getMethodImplementation = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_name, rewriter, eSymbolTypeCode);
+    const Symbol *class_getMethodImplementation_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_stret_name, rewriter, eSymbolTypeCode);
+    const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_name, rewriter, eSymbolTypeCode);
+    const Symbol *msg_forward_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_stret_name, rewriter, eSymbolTypeCode);
     
     if (class_getMethodImplementation)
         m_impl_fn_addr = class_getMethodImplementation->GetAddress().GetOpcodeLoadAddress (target);
     if  (class_getMethodImplementation_stret)
         m_impl_stret_fn_addr = class_getMethodImplementation_stret->GetAddress().GetOpcodeLoadAddress (target);
     if (msg_forward)
         m_msg_forward_addr = msg_forward->GetAddress().GetOpcodeLoadAddress(target);
     if  (msg_forward_stret)
AppleObjCTrampolineHandler::AppleObjCTrampolineHandler (const ProcessSP &process_sp,
     // Look up the addresses for the objc dispatch functions and cache them.  For now I'm inspecting the symbol
     // names dynamically to figure out how to dispatch to them.  If it becomes more complicated than this we can 
     // turn the g_dispatch_functions char * array into a template table, and populate the DispatchFunction map
     // from there.
 
     for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++)
     {
         ConstString name_const_str(g_dispatch_functions[i].name);
-        const Symbol *msgSend_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (name_const_str, eSymbolTypeCode);
+        const Symbol *msgSend_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (name_const_str, rewriter, eSymbolTypeCode);
         if (msgSend_symbol && msgSend_symbol->ValueIsAddress())
         {
             // FixMe: Make g_dispatch_functions static table of DispatchFunctions, and have the map be address->index.
             // Problem is we also need to lookup the dispatch function.  For now we could have a side table of stret & non-stret
             // dispatch functions.  If that's as complex as it gets, we're fine.
             
             lldb::addr_t sym_addr = msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
             

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 Searcher::CallbackReturn
 RSBreakpointResolver::SearchCallback(SearchFilter &filter, SymbolContext &context, Address *, bool)
 {
     ModuleSP module = context.module_sp;
 
     if (!module)
         return Searcher::eCallbackReturnContinue;
 
+    const lldb::SymbolRewriterSP rewriter = context.target_sp ? context.target_sp->GetSymbolRewriter() : nullptr;
+
     // Is this a module containing renderscript kernels?
-    if (nullptr == module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData))
+    if (nullptr == module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), rewriter, eSymbolTypeData))
         return Searcher::eCallbackReturnContinue;
 
     // Attempt to set a breakpoint on the kernel name symbol within the module library.
     // If it's not found, it's likely debug info is unavailable - try to set a
     // breakpoint on <name>.expand.
 
-    const Symbol *kernel_sym = module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
+    const Symbol *kernel_sym = module->FindFirstSymbolWithNameAndType(m_kernel_name, rewriter, eSymbolTypeCode);
     if (!kernel_sym)
     {
         std::string kernel_name_expanded(m_kernel_name.AsCString());
         kernel_name_expanded.append(".expand");
-        kernel_sym = module->FindFirstSymbolWithNameAndType(ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
+        kernel_sym = module->FindFirstSymbolWithNameAndType(ConstString(kernel_name_expanded.c_str()), rewriter, eSymbolTypeCode);
     }
 
     if (kernel_sym)
     {
         Address bp_addr = kernel_sym->GetAddress();
         if (filter.AddressPasses(bp_addr))
             m_breakpoint->AddLocation(bp_addr);
     }

 }
 
 RenderScriptRuntime::ModuleKind
 RenderScriptRuntime::GetModuleKind(const lldb::ModuleSP &module_sp)
 {
     if (module_sp)
     {
         // Is this a module containing renderscript kernels?
-        const Symbol *info_sym = module_sp->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
+        const Symbol *info_sym = module_sp->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), nullptr, eSymbolTypeData);
         if (info_sym)
         {
             return eModuleKindKernelObj;
         }
 
         // Is this the main RS runtime library
         const ConstString rs_lib("libRS.so");
         if (module_sp->GetFileSpec().GetFilename() == rs_lib)
for (size_t idx = 0; idx < s_runtimeHookCount; idx++)
         const HookDefn *hook_defn = &s_runtimeHookDefns[idx];
         if (hook_defn->kind != kind)
         {
             continue;
         }
 
         const char *symbol_name = (archByteSize == 4) ? hook_defn->symbol_name_m32 : hook_defn->symbol_name_m64;
 
-        const Symbol *sym = module->FindFirstSymbolWithNameAndType(ConstString(symbol_name), eSymbolTypeCode);
+        const Symbol *sym = module->FindFirstSymbolWithNameAndType(ConstString(symbol_name), target.GetSymbolRewriter(), eSymbolTypeCode);
         if (!sym)
         {
             if (log)
             {
                 log->Printf("%s - symbol '%s' related to the function %s not found",
                             __FUNCTION__, symbol_name, hook_defn->name);
             }
             continue;
if (module_sp)
                 m_libRSCpuRef = module_sp;
                 break;
             }
             case eModuleKindLibRS:
             {
                 if (!m_libRS)
                 {
                     m_libRS = module_sp;
+                    Target &target = GetProcess()->GetTarget();
                     static ConstString gDbgPresentStr("gDebuggerPresent");
                     const Symbol *debug_present =
-                        m_libRS->FindFirstSymbolWithNameAndType(gDbgPresentStr, eSymbolTypeData);
+                        m_libRS->FindFirstSymbolWithNameAndType(gDbgPresentStr, target.GetSymbolRewriter(), eSymbolTypeData);
                     if (debug_present)
                     {
                         Error error;
                         uint32_t flag = 0x00000001U;
-                        Target &target = GetProcess()->GetTarget();
                         addr_t addr = debug_present->GetLoadAddress(&target);
                         GetProcess()->WriteMemory(addr, &flag, sizeof(flag), error);
                         if (error.Success())
                         {
                             if (log)
                                 log->Printf("%s - debugger present flag set on debugee.", __FUNCTION__);
 
                             m_debuggerPresentFlagged = true;

 #define MAXLINESTR MAXLINESTR_(MAXLINE)
 
 // The .rs.info symbol in renderscript modules contains a string which needs to be parsed.
 // The string is basic and is parsed on a line by line basis.
 bool
 RSModuleDescriptor::ParseRSInfo()
 {
     assert(m_module);
-    const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), eSymbolTypeData);
+    const Symbol *info_sym = m_module->FindFirstSymbolWithNameAndType(ConstString(".rs.info"), nullptr, eSymbolTypeData);
     if (!info_sym)
         return false;
 
     const addr_t addr = info_sym->GetAddressRef().GetFileAddress();
     if (addr == LLDB_INVALID_ADDRESS)
         return false;
 
     const addr_t size = info_sym->GetByteSize();
if (var_list.GetSize() == 1)
         else
         {
             strm.Printf(" - Unknown Type");
         }
     }
     else
     {
         strm.Printf(" - variable identified, but not found in binary");
-        const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(m_name, eSymbolTypeData);
+        const Symbol *s = m_module->m_module->FindFirstSymbolWithNameAndType(m_name, nullptr, eSymbolTypeData);
         if (s)
         {
             strm.Printf(" (symbol exists) ");
         }
     }
 
     strm.EOL();
 }

source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

MemoryHistoryASan::CreateInstance (const ProcessSP &process_sp)
     std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     const size_t num_modules = target_modules.GetSize();
     for (size_t i = 0; i < num_modules; ++i)
     {
         Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
 
         const Symbol* symbol = module_pointer->FindFirstSymbolWithNameAndType(
                 ConstString("__asan_get_alloc_stack"),
+                target.GetSymbolRewriter(),
                 lldb::eSymbolTypeAny);
 
         if (symbol != nullptr)
             return MemoryHistorySP(new MemoryHistoryASan(process_sp));        
     }
 
     return MemoryHistorySP();
 }

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

if (module_sp)
             // "start" symbol in the main executable.
 
             ModuleSP module_sp (GetModule());
 
             if (module_sp)
             {
                 SymbolContextList contexts;
                 SymbolContext context;
-                if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), eSymbolTypeCode, contexts))
+                if (module_sp->FindSymbolsWithNameAndType(ConstString ("start"), nullptr, eSymbolTypeCode, contexts))
                 {
                     if (contexts.GetContextAtIndex(0, context))
                         m_entry_point_address = context.symbol->GetAddress();
                 }
             }
         }
     }
 

source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

lldb_private::InferiorCallMmap (Process *process,
                                 unsigned flags,
                                 addr_t fd,
                                 addr_t offset)
 {
     Thread *thread = process->GetThreadList().GetExpressionExecutionThread().get();
     if (thread == NULL)
         return false;
 
+    Target &target = process->GetTarget();
+
     const bool append = true;
     const bool include_symbols = true;
     const bool include_inlines = false;
     SymbolContextList sc_list;
     const uint32_t count
-      = process->GetTarget().GetImages().FindFunctions (ConstString ("mmap"), 
-                                                        eFunctionNameTypeFull,
-                                                        include_symbols,
-                                                        include_inlines,
-                                                        append, 
-                                                        sc_list);
+      = target.GetImages().FindFunctions (ConstString ("mmap"), 
+                                          target.GetSymbolRewriter(),
     if (count > 0)
     {
         SymbolContext sc;
         if (sc_list.GetContextAtIndex(0, sc))
         {
             const uint32_t range_scope = eSymbolContextFunction | eSymbolContextSymbol;
             const bool use_inline_block_range = false;
             EvaluateExpressionOptions options;
if (count > 0)
               if (prot & eMmapProtExec)
                 prot_arg |= PROT_EXEC;
               if (prot & eMmapProtRead)
                 prot_arg |= PROT_READ;
               if (prot & eMmapProtWrite)
                 prot_arg |= PROT_WRITE;
             }
 
-            const ArchSpec arch =  process->GetTarget().GetArchitecture();
-            flags_arg = process->GetTarget().GetPlatform()->ConvertMmapFlagsToPlatform(arch,flags);
+            const ArchSpec arch =  target.GetArchitecture();
+            flags_arg = target.GetPlatform()->ConvertMmapFlagsToPlatform(arch,flags);
 
             AddressRange mmap_range;
             if (sc.GetAddressRange(range_scope, 0, use_inline_block_range, mmap_range))
             {
-                ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
+                ClangASTContext *clang_ast_context = target.GetScratchClangASTContext();
                 CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
                 lldb::addr_t args[] = { addr, length, prot_arg, flags_arg, fd, offset };
                 lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallFunction(*thread, mmap_range.GetBaseAddress(),
                                                                            clang_void_ptr_type, args, options));
                 if (call_plan_sp)
                 {
                     DiagnosticManager diagnostics;
 

 bool
 lldb_private::InferiorCallMunmap (Process *process,
                                   addr_t addr,
                                   addr_t length)
 {
    Thread *thread = process->GetThreadList().GetExpressionExecutionThread().get();
    if (thread == NULL)
        return false;
-   
+    Target &target = process->GetTarget();
+
    const bool append = true;
    const bool include_symbols = true;
    const bool include_inlines = false;
    SymbolContextList sc_list;
    const uint32_t count
-     = process->GetTarget().GetImages().FindFunctions (ConstString ("munmap"), 
-                                                       eFunctionNameTypeFull,
-                                                       include_symbols, 
-                                                       include_inlines,
-                                                       append, 
-                                                       sc_list);
+     = target.GetImages().FindFunctions (ConstString ("munmap"), 
+                                         target.GetSymbolRewriter(),
    if (count > 0)
    {
        SymbolContext sc;
        if (sc_list.GetContextAtIndex(0, sc))
        {
             const uint32_t range_scope = eSymbolContextFunction | eSymbolContextSymbol;
             const bool use_inline_block_range = false;
             EvaluateExpressionOptions options;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (m_supports_qSymbol && m_qSymbol_requests_done == false)
                         std::string symbol_name;
                         if (response.GetHexByteString(symbol_name))
                         {
                             if (symbol_name.empty())
                                 return;
 
                             addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
                             lldb_private::SymbolContextList sc_list;
-                            if (process->GetTarget().GetImages().FindSymbolsWithNameAndType(ConstString(symbol_name), eSymbolTypeAny, sc_list))
+                            Target &target = process->GetTarget();
+                            if (target.GetImages().FindSymbolsWithNameAndType(ConstString(symbol_name), target.GetSymbolRewriter(), eSymbolTypeAny, sc_list))
                             {
                                 const size_t num_scs = sc_list.GetSize();
                                 for (size_t sc_idx=0; sc_idx<num_scs && symbol_load_addr == LLDB_INVALID_ADDRESS; ++sc_idx)
                                 {
                                     SymbolContext sc;
                                     if (sc_list.GetContextAtIndex(sc_idx, sc))
                                     {
                                         if (sc.symbol)
if (m_supports_qSymbol && m_qSymbol_requests_done == false)
                                             case eSymbolTypeResolver:
                                             case eSymbolTypeData:
                                             case eSymbolTypeRuntime:
                                             case eSymbolTypeException:
                                             case eSymbolTypeObjCClass:
                                             case eSymbolTypeObjCMetaClass:
                                             case eSymbolTypeObjCIVar:
                                             case eSymbolTypeReExported:
-                                                symbol_load_addr = sc.symbol->GetLoadAddress(&process->GetTarget());
+                                                symbol_load_addr = sc.symbol->GetLoadAddress(&target);
                                                 break;
                                             }
                                         }
                                     }
                                 }
                             }
                             // This is the normal path where our symbol lookup was successful and we want
                             // to send a packet with the new symbol value and see if another lookup needs to be

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name)
 {
     Symbol *objc_class_symbol = NULL;
     if (m_obj_file)
     {
         Symtab *symtab = m_obj_file->GetSymtab ();
         if (symtab)
         {
-            objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name, 
+            objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name,
+                                                                        nullptr,
                                                                         eSymbolTypeObjCClass, 
                                                                         Symtab::eDebugNo, 
                                                                         Symtab::eVisibilityAny);
         }
     }
     return objc_class_symbol;
 }
 
if ((tag == DW_TAG_variable) ||
                             ConstString const_name(mangled ? mangled : name);
                             ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile();
                             if (debug_map_objfile)
                             {
                                 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
                                 if (debug_map_symtab)
                                 {
                                     Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name,
+                                                                                                           nullptr,
                                                                                                            eSymbolTypeData,
                                                                                                            Symtab::eDebugYes,
                                                                                                            Symtab::eVisibilityExtern);
                                     if (exe_symbol)
                                     {
                                         if (exe_symbol->ValueIsAddress())
                                         {
                                             const addr_t exe_file_addr = exe_symbol->GetAddressRef().GetFileAddress();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos))
                             // addresses are in the .o file, and the load address is adjusted
                             // to match where it ended up in the final executable! We do this
                             // before we parse any dwarf info so that when it goes get parsed
                             // all section/offset addresses that get registered will resolve
                             // correctly to the new addresses in the main executable.
 
                             // First we find the original symbol in the .o file's symbol table
                             Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled),
+                                                                                                 nullptr,
                                                                                                  eSymbolTypeCode,
                                                                                                  Symtab::eDebugNo,
                                                                                                  Symtab::eVisibilityAny);
                             if (oso_fun_symbol)
                             {
                                 // Add the inverse OSO file address to debug map entry mapping
                                 exe_symfile->AddOSOFileRange (this,
                                                               exe_symbol->GetAddressRef().GetFileAddress(),
if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos))
                             // correctly to the new addresses in the main executable. We
                             // initially set the section size to be 1 byte, but will need to
                             // fix up these addresses further after all globals have been
                             // parsed to span the gaps, or we can find the global variable
                             // sizes from the DWARF info as we are parsing.
 
                             // Next we find the non-stab entry that corresponds to the N_GSYM in the .o file
                             Symbol *oso_gsym_symbol = oso_symtab->FindFirstSymbolWithNameAndType (exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled),
+                                                                                                  nullptr,
                                                                                                   eSymbolTypeData,
                                                                                                   Symtab::eDebugNo,
                                                                                                   Symtab::eVisibilityAny);
                             if (exe_symbol && oso_gsym_symbol &&
                                 exe_symbol->ValueIsAddress() &&
                                 oso_gsym_symbol->ValueIsAddress())
                             {
                                 // Add the inverse OSO file address to debug map entry mapping
SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die,
     SymbolFileDWARF *oso_dwarf = NULL;
     TypeSP type_sp;
     ObjectFile *module_objfile = m_obj_file->GetModule()->GetObjectFile();
     if (module_objfile)
     {
         Symtab *symtab = module_objfile->GetSymtab();
         if (symtab)
         {
-            Symbol *objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(type_name, eSymbolTypeObjCClass, Symtab::eDebugAny, Symtab::eVisibilityAny);
+            Symbol *objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(type_name, nullptr, eSymbolTypeObjCClass, Symtab::eDebugAny, Symtab::eVisibilityAny);
             if (objc_class_symbol)
             {
                 // Get the N_SO symbol that contains the objective C class symbol as this
                 // should be the .o file that contains the real definition...
                 const Symbol *source_file_symbol = symtab->GetParent(objc_class_symbol);
 
                 if (source_file_symbol && source_file_symbol->GetType() == eSymbolTypeSourceFile)
                 {

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 SystemRuntimeMacOSX::ReadLibdispatchOffsetsAddress ()
 {
     if (m_dispatch_queue_offsets_addr != LLDB_INVALID_ADDRESS)
         return;
 
     static ConstString g_dispatch_queue_offsets_symbol_name ("dispatch_queue_offsets");
     const Symbol *dispatch_queue_offsets_symbol = NULL;
 
+    Target &target = m_process->GetTarget();
+
     // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6 ("Snow Leopard")
     ModuleSpec libSystem_module_spec (FileSpec("libSystem.B.dylib", false));
-    ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule (libSystem_module_spec));
+    ModuleSP module_sp(target.GetImages().FindFirstModule (libSystem_module_spec));
     if (module_sp)
-        dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
+        dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, target.GetSymbolRewriter(), eSymbolTypeData);
     
     // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion") and later
     if (dispatch_queue_offsets_symbol == NULL)
     {
         ModuleSpec libdispatch_module_spec (FileSpec("libdispatch.dylib", false));
-        module_sp = m_process->GetTarget().GetImages().FindFirstModule (libdispatch_module_spec);
+        module_sp = target.GetImages().FindFirstModule (libdispatch_module_spec);
         if (module_sp)
-            dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
+            dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, target.GetSymbolRewriter(), eSymbolTypeData);
     }
     if (dispatch_queue_offsets_symbol)
-        m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetLoadAddress(&m_process->GetTarget());
+        m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetLoadAddress(&target);
 }
 
 void
 SystemRuntimeMacOSX::ReadLibdispatchOffsets ()
 {
     if (m_libdispatch_offsets.IsValid())
         return;
 

 SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress ()
 {
     if (m_libpthread_layout_offsets_addr != LLDB_INVALID_ADDRESS)
         return;
 
     static ConstString g_libpthread_layout_offsets_symbol_name ("pthread_layout_offsets");
     const Symbol *libpthread_layout_offsets_symbol = NULL;
 
+    Target &target = m_process->GetTarget();
+
     ModuleSpec libpthread_module_spec (FileSpec("libsystem_pthread.dylib", false));
-    ModuleSP module_sp (m_process->GetTarget().GetImages().FindFirstModule (libpthread_module_spec));
+    ModuleSP module_sp (target.GetImages().FindFirstModule (libpthread_module_spec));
     if (module_sp)
     {
         libpthread_layout_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType 
-                                                           (g_libpthread_layout_offsets_symbol_name, eSymbolTypeData);
+                                                           (g_libpthread_layout_offsets_symbol_name, target.GetSymbolRewriter(), eSymbolTypeData);
         if (libpthread_layout_offsets_symbol)
         {
-            m_libpthread_layout_offsets_addr = libpthread_layout_offsets_symbol->GetLoadAddress(&m_process->GetTarget());
+            m_libpthread_layout_offsets_addr = libpthread_layout_offsets_symbol->GetLoadAddress(&target);
         }
     }
 }
 
 void
 SystemRuntimeMacOSX::ReadLibpthreadOffsets ()
 {
     if (m_libpthread_offsets.IsValid())

 SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress ()
 {
     if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS)
         return;
 
     static ConstString g_libdispatch_tsd_indexes_symbol_name ("dispatch_tsd_indexes");
     const Symbol *libdispatch_tsd_indexes_symbol = NULL;
 
+    Target &target = m_process->GetTarget();
+
     ModuleSpec libpthread_module_spec (FileSpec("libdispatch.dylib", false));
-    ModuleSP module_sp (m_process->GetTarget().GetImages().FindFirstModule (libpthread_module_spec));
+    ModuleSP module_sp (target.GetImages().FindFirstModule (libpthread_module_spec));
     if (module_sp)
     {
         libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType 
-                                                           (g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData);
+                                                           (g_libdispatch_tsd_indexes_symbol_name, target.GetSymbolRewriter(), eSymbolTypeData);
         if (libdispatch_tsd_indexes_symbol)
         {
-            m_dispatch_tsd_indexes_addr = libdispatch_tsd_indexes_symbol->GetLoadAddress(&m_process->GetTarget());
+            m_dispatch_tsd_indexes_addr = libdispatch_tsd_indexes_symbol->GetLoadAddress(&target);
         }
     }
 }
 
 void
 SystemRuntimeMacOSX::ReadLibdispatchTSDIndexes ()
 {
     if (m_libdispatch_tsd_indexes.IsValid())
SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized ()
     addr_t queue_info_data_offset_address = LLDB_INVALID_ADDRESS;
     addr_t item_info_version_address = LLDB_INVALID_ADDRESS;
     addr_t item_info_data_offset_address = LLDB_INVALID_ADDRESS;
     Target &target = m_process->GetTarget();
 
 
     static ConstString introspection_dispatch_queue_info_version ("__introspection_dispatch_queue_info_version");
     SymbolContextList sc_list;
-    if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list) > 0)
+    if (target.GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_version, target.GetSymbolRewriter(), eSymbolTypeData, sc_list) > 0)
     {
         SymbolContext sc;
         sc_list.GetContextAtIndex (0, sc);
         AddressRange addr_range;
         sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
         queue_info_version_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
     }
     sc_list.Clear();
 
     static ConstString introspection_dispatch_queue_info_data_offset ("__introspection_dispatch_queue_info_data_offset");
-    if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_data_offset, eSymbolTypeData, sc_list) > 0)
+    if (target.GetImages().FindSymbolsWithNameAndType (introspection_dispatch_queue_info_data_offset, target.GetSymbolRewriter(), eSymbolTypeData, sc_list) > 0)
     {
         SymbolContext sc;
         sc_list.GetContextAtIndex (0, sc);
         AddressRange addr_range;
         sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
         queue_info_data_offset_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
     }
     sc_list.Clear();
 
     static ConstString introspection_dispatch_item_info_version ("__introspection_dispatch_item_info_version");
-    if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_version, eSymbolTypeData, sc_list) > 0)
+    if (target.GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_version, target.GetSymbolRewriter(), eSymbolTypeData, sc_list) > 0)
     {
         SymbolContext sc;
         sc_list.GetContextAtIndex (0, sc);
         AddressRange addr_range;
         sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
         item_info_version_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
     }
     sc_list.Clear();
 
     static ConstString introspection_dispatch_item_info_data_offset ("__introspection_dispatch_item_info_data_offset");
-    if (m_process->GetTarget().GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_data_offset, eSymbolTypeData, sc_list) > 0)
+    if (target.GetImages().FindSymbolsWithNameAndType (introspection_dispatch_item_info_data_offset, target.GetSymbolRewriter(), eSymbolTypeData, sc_list) > 0)
     {
         SymbolContext sc;
         sc_list.GetContextAtIndex (0, sc);
         AddressRange addr_range;
         sc.GetAddressRange (eSymbolContextSymbol, 0, false, addr_range);
         item_info_data_offset_address = addr_range.GetBaseAddress().GetLoadAddress(&target);
     }
 

source/Symbol/CMakeLists.txt

add_lldb_library(lldbSymbol
   GoASTContext.cpp
   JavaASTContext.cpp
   LineEntry.cpp
   LineTable.cpp
   ObjectFile.cpp
   Symbol.cpp
   SymbolContext.cpp
   SymbolFile.cpp
+  SymbolRewriter.cpp
   SymbolVendor.cpp
   Symtab.cpp
   Type.cpp
   TypeList.cpp
   TypeMap.cpp 
   TypeSystem.cpp
   UnwindPlan.cpp
   UnwindTable.cpp
   Variable.cpp
   VariableList.cpp
   VerifyDecl.cpp
   )

source/Symbol/Symbol.cpp

Symbol::ResolveReExportedSymbolInModuleSpec (Target &target,
     if (module_sp)
     {
         // There should not be cycles in the reexport list, but we don't want to crash if there are so make sure
         // we haven't seen this before:
         if (!seen_modules.AppendIfNeeded(module_sp))
             return nullptr;
         
         lldb_private::SymbolContextList sc_list;
-        module_sp->FindSymbolsWithNameAndType(reexport_name, eSymbolTypeAny, sc_list);
+        module_sp->FindSymbolsWithNameAndType(reexport_name, target.GetSymbolRewriter(), eSymbolTypeAny, sc_list);
         const size_t num_scs = sc_list.GetSize();
         if (num_scs > 0)
         {
             for (size_t i=0; i<num_scs; ++i)
             {
                 lldb_private::SymbolContext sc;
                 if (sc_list.GetContextAtIndex(i, sc))
                 {

source/Symbol/SymbolRewriter.cpp

+//===-- SymbolRewriter.cpp --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/Log.h"
+#include "lldb/Symbol/SymbolRewriter.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Regex.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/YAMLParser.h"
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+
+SymbolRewriter::SymbolRewriter()
+{
+}
+
+static std::string
+getString(yaml::ScalarNode *n)
+{
+    SmallString<32> storage;
+    StringRef ref;
+
+    ref = n->getValue(storage);
+
+    return ref.str ();
+}
+
+void
+SymbolRewriter::LoadMap(const FileSpec &path)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
+    auto str_path = path.GetPath ();
+
+    if (log)
+    {
+        log->Printf("loading rewrite maps from %s", str_path.c_str ());
+    }
+
+    ErrorOr<std::unique_ptr<MemoryBuffer>> mem_buffer_or_err = MemoryBuffer::getFile (str_path);
+    if (std::error_code err = mem_buffer_or_err.getError())
+    {
+        report_fatal_error ("Unable to read rewrite map '" + str_path +
+                            "': " + err.message());
+        return;
+    }
+    std::unique_ptr<MemoryBuffer> mem_buffer = std::move(mem_buffer_or_err.get());
+
+    SourceMgr source_mgr;
+    yaml::Stream yaml_stream(mem_buffer->getBuffer (), source_mgr);
+
+    for (auto &stream : yaml_stream)
+    {
+#define PARSE_CHECK(COND, MESSAGE)                                           \
+        if (COND)                                                            \
+        {                                                                    \
+            report_fatal_error ("Unable to parse rewrite map '" + str_path + \
+                                "': " + MESSAGE);                            \
+            continue;                                                        \
+        }
+
+        auto root_map = dyn_cast<yaml::MappingNode>(stream.getRoot());
+        PARSE_CHECK (!root_map, "root element is not a map")
+
+        auto map = std::make_shared<RewriteMap> ();
+        m_rewrite_maps.push_back (map);
+
+        for (auto &entry : *root_map)
+        {
+            static const std::string rewrite_type_function = "function";
+            static const std::string rewrite_type_global_variable = "global variable";
+            static const std::string rewrite_type_global_alias = "global alias";
+
+            auto key = dyn_cast<yaml::ScalarNode>(entry.getKey ());
+            PARSE_CHECK(!key, "malformed rewrite entry")
+
+            auto value = dyn_cast<yaml::MappingNode>(entry.getValue ());
+            PARSE_CHECK(!value, "malformed rewrite entry")
+
+            auto rewrite_type = getString (key);
+
+            if (rewrite_type == rewrite_type_global_alias)
+            {
+              if (log)
+                log->Printf("ignoring rewrite type 'global alias' in '%s'", str_path.c_str());
+              continue;
+            }
+
+            PARSE_CHECK (rewrite_type != rewrite_type_function &&
+                         rewrite_type != rewrite_type_global_variable,
+                         "'" + rewrite_type + "' is not a valid rewrite type")
+
+            static const std::string descriptor_field_source = "source";
+            static const std::string descriptor_field_target = "target";
+            static const std::string descriptor_field_transform = "transform";
+            static const std::string descriptor_field_naked = "naked";
+            std::string source;
+            std::string target;
+            std::string transform;
+            std::string naked;
+
+            for (auto &field : *value)
+            {
+                auto field_key = dyn_cast<yaml::ScalarNode> (field.getKey ());
+                PARSE_CHECK(!field_key, "malformed rewrite entry")
+
+                auto field_value = dyn_cast<yaml::ScalarNode> (field.getValue ());
+                PARSE_CHECK(!field_value, "malformed rewrite entry")
+
+                auto str_key = getString (field_key);
+                auto str_value = getString (field_value);
+
+                if (str_key == descriptor_field_source)
+                    source = str_value;
+                else if (str_key == descriptor_field_target)
+                    target = str_value;
+                else if (str_key == descriptor_field_transform)
+                    transform = str_value;
+                else if (str_key == descriptor_field_naked)
+                    naked = str_value;
+                else
+                    PARSE_CHECK (true, "'" + str_key + "' is not a valid key in a rewrite entry")
+            }
+
+            PARSE_CHECK (source.size () == 0, "missing source in rewrite entry")
+
+            if (!target.empty ())
+                map->m_direct_map[ConstString(source)] = ConstString(target);
+            else if (!transform.empty ())
+                map->m_transform_map[ConstString(source)] = ConstString(transform);
+            else
+                PARSE_CHECK (true, "target and transform are missing in rewrite entry for '" + source + "'")
+        }
+#undef PARSE_CHECK
+    }
+
+    if (log)
+    {
+        log->Printf("loaded rewrite maps from %s", str_path.c_str ());
+    }
+}
+
+ConstString
+SymbolRewriter::Rewrite(const ConstString& name)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
+    ConstString result = name;
+
+    for (auto &map : m_rewrite_maps)
+    {
+        auto entry_it = map->m_direct_map.find(result);
+        if (entry_it != map->m_direct_map.end ())
+        {
+            result = entry_it->second;
+            continue;
+        }
+
+        for (const auto &entry : map->m_transform_map)
+        {
+            std::string error;
+            std::string trans;
+
+            trans = Regex (entry.first.AsCString ()).sub (entry.second.AsCString(),
+                                                          result.AsCString (),
+                                                          &error);
+
+            if (strcmp (trans.c_str (), result.AsCString ()) != 0)
+            {
+                /* Cache entry in direct rewrite map for faster lookups. */
+                auto new_result = ConstString (trans.c_str ());
+                map->m_direct_map[result] = new_result;
+                result = new_result;
+                break;
+            }
+        }
+    }
+
+    if (log)
+    {
+        log->Printf("rewrote symbol %s to %s", name.AsCString (), result.AsCString ());
+    }
+
+    return result;
+}

source/Symbol/Symtab.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/SymbolRewriter.h"
 #include "lldb/Symbol/Symtab.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Symtab::Symtab(ObjectFile *objfile)
for (size_t idx = start_idx; idx < count; ++idx)
                 return &m_symbols[idx];
             }
         }
     }
     return nullptr;
 }
 
 size_t
-Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes)
+Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, const SymbolRewriterSP rewriter, SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes)
 {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
+
+    ConstString rewrittenName = RewriteName(rewriter, name);
+
     // Initialize all of the lookup by name indexes before converting NAME
     // to a uniqued string NAME_STR below.
     if (!m_name_indexes_computed)
         InitNameIndexes();
 
     if (name)
     {
         // The string table did have a string that matched, but we need
         // to check the symbols and match the symbol_type if any was given.
-        AppendSymbolIndexesWithNameAndType (name, symbol_type, symbol_indexes);
+        AppendSymbolIndexesWithNameAndType (rewrittenName, symbol_type, symbol_indexes);
     }
     return symbol_indexes.size();
 }
 
 size_t
-Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes)
+Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, const SymbolRewriterSP rewriter, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes)
 {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
+
+    ConstString rewrittenName = RewriteName(rewriter, name);
+
     // Initialize all of the lookup by name indexes before converting NAME
     // to a uniqued string NAME_STR below.
     if (!m_name_indexes_computed)
         InitNameIndexes();
 
     if (name)
     {
         // The string table did have a string that matched, but we need
         // to check the symbols and match the symbol_type if any was given.
-        AppendSymbolIndexesWithNameAndType (name, symbol_type, symbol_debug_type, symbol_visibility, symbol_indexes);
+        AppendSymbolIndexesWithNameAndType (rewrittenName, symbol_type, symbol_debug_type, symbol_visibility, symbol_indexes);
     }
     return symbol_indexes.size();
 }
 
 size_t
 Symtab::FindAllSymbolsMatchingRexExAndType (const RegularExpression &regex, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes)
 {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type, symbol_visibility, symbol_indexes);
     return symbol_indexes.size();
 }
 
 Symbol *
-Symtab::FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
+Symtab::FindFirstSymbolWithNameAndType (const ConstString &name, const SymbolRewriterSP rewriter, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
 {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
+
+    ConstString rewrittenName = RewriteName (rewriter, name);
+
     if (!m_name_indexes_computed)
         InitNameIndexes();
 
     if (name)
     {
         std::vector<uint32_t> matching_indexes;
         // The string table did have a string that matched, but we need
         // to check the symbols and match the symbol_type if any was given.
-        if (AppendSymbolIndexesWithNameAndType (name, symbol_type, symbol_debug_type, symbol_visibility, matching_indexes))
+        if (AppendSymbolIndexesWithNameAndType (rewrittenName, symbol_type, symbol_debug_type, symbol_visibility, matching_indexes))
         {
             std::vector<uint32_t>::const_iterator pos, end = matching_indexes.end();
             for (pos = matching_indexes.begin(); pos != end; ++pos)
             {
                 Symbol *symbol = SymbolAtIndex(*pos);
 
-                if (symbol->Compare(name, symbol_type))
+                if (symbol->Compare(rewrittenName, symbol_type))
                     return symbol;
             }
         }
     }
     return nullptr;
 }
 
 typedef struct
if (num_indices > 0)
                 sc_list.AppendIfUnique(sc, merge_symbol_into_function);
         }
     }
 }
 
 
 size_t
 Symtab::FindFunctionSymbols (const ConstString &name,
+                             const SymbolRewriterSP rewriter,
                              uint32_t name_type_mask,
                              SymbolContextList& sc_list)
 {
     size_t count = 0;
     std::vector<uint32_t> symbol_indexes;
     
     const char *name_cstr = name.GetCString();
     
     // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup()
     assert ((name_type_mask & eFunctionNameTypeAuto) == 0);
 
     if (name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull))
     {
         std::vector<uint32_t> temp_symbol_indexes;
-        FindAllSymbolsWithNameAndType (name, eSymbolTypeAny, temp_symbol_indexes);
+        FindAllSymbolsWithNameAndType (name, rewriter, eSymbolTypeAny, temp_symbol_indexes);
 
         unsigned temp_symbol_indexes_size = temp_symbol_indexes.size();
         if (temp_symbol_indexes_size > 0)
         {
             std::lock_guard<std::recursive_mutex> guard(m_mutex);
             for (unsigned i = 0; i < temp_symbol_indexes_size; i++)
             {
                 SymbolContext sym_ctx;
if (child_idx != UINT32_MAX && child_idx > 0)
             const Symbol *symbol = SymbolAtIndex (idx);
             const uint32_t sibling_idx = symbol->GetSiblingIndex();
             if (sibling_idx != UINT32_MAX && sibling_idx > child_idx)
                 return symbol;
         }
     }
     return NULL;
 }
+
+ConstString
+Symtab::RewriteName (const SymbolRewriterSP rewriter, ConstString name)
+{
+    if (rewriter)
+    {
+      return rewriter->Rewrite (name);
+    }
+
+    return name;
+}

source/Target/ObjCLanguageRuntime.cpp

ObjCLanguageRuntime::LookupInCompleteClassCache (ConstString &name)
     
     if (m_negative_complete_class_cache.count(name) > 0)
         return TypeSP();
     
     const ModuleList &modules = m_process->GetTarget().GetImages();
 
     SymbolContextList sc_list;
     const size_t matching_symbols = modules.FindSymbolsWithNameAndType (name,
+                                                                        m_process->GetTarget().GetSymbolRewriter(),
                                                                         eSymbolTypeObjCClass,
                                                                         sc_list);
     
     if (matching_symbols)
     {
         SymbolContext sc;
         
         sc_list.GetContextAtIndex(0, sc);

source/Target/Target.cpp

Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp,
     : TargetProperties(this),
       Broadcaster(debugger.GetBroadcasterManager(), Target::GetStaticBroadcasterClass().AsCString()),
       ExecutionContextScope(),
       m_debugger(debugger),
       m_platform_sp(platform_sp),
       m_mutex(),
       m_arch(target_arch),
       m_images(this),
+      m_symbol_rewriter(),
       m_section_load_history(),
       m_breakpoint_list(false),
       m_internal_breakpoint_list(true),
       m_watchpoint_list(),
       m_process_sp(),
       m_search_filter_sp(),
       m_image_search_paths(ImageSearchPathsChanged, this),
       m_ast_importer_sp(),