Make Module::GetSectionList output consistent

[labath]

Summary

The result of Module::GetSectionList depended on whether the symbol
vendor has been loaded (which would augment the section list with the
extra sections that have been found by the vendor).

Although this bit was documented in the function header, this makes a
quirky api, as other Module functions have no requirement to load the
vendor explicitly -- instead they will do it on demand. In practice,
what this meant is that the user would nearly always get the augmented
section list (because by the time he requested it, it's likely something
would have loaded the vendor already), *except* if all that he was doing
was loading a module and immediately dumping out the sections like
lldb-test does.

[labath]

tools/lldb-test/lldb-test.cpp

75

The expliciting symbol filespec setting was short-circuiting the regular search process. I removed it as there was no test depending on this yet.

[clayborg]

source/Core/Module.cpp

1289

should we pass "obj_file" down into the SymbolVendor::CreateSections(...) call for the case where the symbol vendor is using the same ObjectFile that it can just return?

[labath]

source/Core/Module.cpp

1289

I don't think an extra parameter is needed to achieve this, as this is something that the symbol vendor should already know about based on how it was constructed.

And after looking up the implementation, it seems this is already how it works right now: SymbolVendorELF (the only non-trivial implementation of this function) is only constructed if it manages to find debug info in an alternative symbol file (there's an if (llvm::sys::fs::equivalent(candidate_file_spec.GetPath(), module_file_spec.GetPath())) check in Symbols::LocateExecutableSymbolFile). If we fail to construct a SymbolVendorELF then a default SymbolVendor instance is created in SymbolVendor::FindPlugin (and that one has a no-op implementation of this function).

[labath]

Greg, with my last comment in mind, how do you feel about this patch?

[davide]

LGTM.

source/Core/Module.cpp

1289

I agree with Pavel's reasoning here.

[clayborg]

Back from vacation, sorry for the delay. Only one question on who is actually responsible for creating the sections. I vote to let SymbolVendor::CreateSection() always do the work. Let me know what you think.

source/Core/Module.cpp

1287–1288

If we are going to let the symbol vendor do it's thing, then we should probably not manually call ObjectFile::CreateSections. The idea behind SymbolVendor is that _it_ knows how best to do things for one or more object files. Can we move all logic for parsing sections into the SymbolVendor::CreateSections()?

[labath]

source/Core/Module.cpp

1287–1288

I like that idea. I'm going to take a look to see how that could be done.

[labath]

This version moves the logic for the building of unified section list into the
symbol vendor plugin.

The idea was to keep the construction of section lists of individual object
files inside the ObjectFile object, and then have the SymbolVendor do the
merging. This was easy to achieve for the SymbolVendorELF, and I'm quite happy
about how things look like there.

However, I had a lot of trouble with making this work for the MachO
objectfile+symbolvendor combo, because there the section building is
intertwined with the load command parsing and the building of the unified
sections list. In particular, the parse function seems to be doing some dodgy
things like taking a section from the "unified" list and inserting it into
per-object-file list. So, here I had to leave the building of the unified list
in the ObjectFile class, and the SymbolVendor just orchestrates the functions
to be called in the right order (for this I needed to cast the ObjectFile into
ObjectFileMachO, which seemingly adds a new dependency to the symbol vendor,
but this is not really true, as the vendor was already checking the type of the
object file via the GetPluginName() function). It would be great if someone
with more MachO knowledge could look at the CreateSections function and split
it up into more manageable chunks.

The other sub-optimal design decision I had to make was due to the mutual
recursion of the Module, SymbolVendor and SymbolFile classes: SymbolVendor
creates a SymbolFile class, which expect that the Module's section list is
already constructed, but SymbolVendor is the one constructing the list. This
means that I couldn't just construct the SymbolVendor and have the Module ask
it for the section list, but I had to make the vendor directly update the
section list within the module (before constructing the symbolfile class).

On the plus side, I really like that I was able to remove the
"update_module_section_list" argument from the ObjectFile::GetSectionList
function, which was very dodgy as well, because whether the module's section
list was updated, depended on the value of the argument of the *first* call of
that function.

All in all, I think patch cleans up the unified section list handling, but only
by a small bit. Let me know what you think.

[labath]

Remove the changes to source/Plugins/SymbolVendor/CMakeLists.txt that snuck in
(I was experimenting with enabling the plugin on non-mac systems, but realized
that's not possible right now).

[labath]

Explicitly requesting re-review to make sure this is on your radar.

We have a new patch that <D44041> would benefit from this, but if this is not ready to go in yet (it's a turned into a fairly big refactor), I'll probably add a workaround to lldb-test to make that patch testable.

[clayborg]

Looks fine, a bit hard to tell exactly what is going on so I will accept as long as the following things are still true:

• each lldb_private::ObjectFile has its own section list that perfectly mirrors exactly what is in that object file and that file alone
• The lldb_private::Module hands out a unified section list that is populated by the symbol vendor where it uses one or more object files to create the unified section list

[labath]

I can try to split the patch up a bit if you think it will make things easier. I'm not sure how much I will be able to do that, as the patch is not that big, it just needs to touch a bunch of files for the changed interfaces.

In D42955#1026061, @clayborg wrote:

Looks fine, a bit hard to tell exactly what is going on so I will accept as long as the following things are still true:

• each lldb_private::ObjectFile has its own section list that perfectly mirrors exactly what is in that object file and that file alone

This part is not completely true. It is true for ObjectFileELF/COFF/JIT, and is enforced by the fact that the ObjectFile::GetSections does not even have access to the unified section list. However, it is *not* true for ObjectFileMachO (but that is not because of this patch). This is the problem I've had when trying to refactor this (and it's the reason the ObjectFileMachO<->SymbolVendorMacOSX interface is a bit weird). It seems that the ObjectFileMachO sometimes takes a section from the unified list and adds it to it's own list (or at least it appears to be doing that). I don't know enough about MachO to understand why is it doing that, or how to fix it. I've highlighted the places in the code where I think this is happening. Any suggestions would be welcome here.

• The lldb_private::Module hands out a unified section list that is populated by the symbol vendor where it uses one or more object files to create the unified section list

This part is true.

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

1415–1416

Here we are grabbing a section from the unified section list.

1562

And here it gets added to the object file's section list.

[clayborg]

In D42955#1026116, @labath wrote:

I can try to split the patch up a bit if you think it will make things easier. I'm not sure how much I will be able to do that, as the patch is not that big, it just needs to touch a bunch of files for the changed interfaces.

In D42955#1026061, @clayborg wrote:

Looks fine, a bit hard to tell exactly what is going on so I will accept as long as the following things are still true:

• each lldb_private::ObjectFile has its own section list that perfectly mirrors exactly what is in that object file and that file alone

This part is not completely true. It is true for ObjectFileELF/COFF/JIT, and is enforced by the fact that the ObjectFile::GetSections does not even have access to the unified section list. However, it is *not* true for ObjectFileMachO (but that is not because of this patch). This is the problem I've had when trying to refactor this (and it's the reason the ObjectFileMachO<->SymbolVendorMacOSX interface is a bit weird). It seems that the ObjectFileMachO sometimes takes a section from the unified list and adds it to it's own list (or at least it appears to be doing that). I don't know enough about MachO to understand why is it doing that, or how to fix it. I've highlighted the places in the code where I think this is happening. Any suggestions would be welcome here.

The dSYM file is a mach-o file that contains symbols only, It is because the dSYM file (stand alone debug info file) has all of the section definitions from the main executable, but no section content for everything except the DWARF debug info. The DWARF only exists in the dSYM file. The dSYM file also has all of the symbols as it gets made before the executable is stripped. Many symbols refer to a section by section index, so that is why we must have the section definitions in the dSYM file. So the dSYM wants the sections from the main executable so it can access text and data if needed since symbol refer to these and someone might ask a symbol from a dSYM file what its instructions are. So the dSYM uses the real sections from the main executable file instead of its own.

• The lldb_private::Module hands out a unified section list that is populated by the symbol vendor where it uses one or more object files to create the unified section list

This part is true.

[labath]

In D42955#1026175, @clayborg wrote:

The dSYM file is a mach-o file that contains symbols only, It is because the dSYM file (stand alone debug info file) has all of the section definitions from the main executable, but no section content for everything except the DWARF debug info. The DWARF only exists in the dSYM file. The dSYM file also has all of the symbols as it gets made before the executable is stripped. Many symbols refer to a section by section index, so that is why we must have the section definitions in the dSYM file. So the dSYM wants the sections from the main executable so it can access text and data if needed since symbol refer to these and someone might ask a symbol from a dSYM file what its instructions are. So the dSYM uses the real sections from the main executable file instead of its own.

I see, thanks for the explanation. The code makes more sense now.

But now I have another question. Is this an intentional design decision that we want to preserve; or just how things happen to work now, and should be cleaned up in the future (to achieve the "ObjectFile contains only own sections" invariant)?

I'm asking this, because if it's the former then this patch probably needs to be redone, as it tries to enforce that invariant (and then needs to jump through hoops to enable the ObjectFileMachO use case). OTOH, if it's the latter, then I think this is a step in the right direction, as it makes it obvious that ObjectFileMachO is doing something that it shouldn't (and at the same time it makes it harder for other ObjectFiles to do the same).

BTW, the same situation (symbol file containing empty section definitions for code&data) can happen on elf targets as well (if the symbol file is produced with strip --only-keep-debug), but everything seems to be working fine, presumably because all consumers are accessing the sections through the unified section list.

[clayborg]

In D42955#1026197, @labath wrote:

In D42955#1026175, @clayborg wrote:

The dSYM file is a mach-o file that contains symbols only, It is because the dSYM file (stand alone debug info file) has all of the section definitions from the main executable, but no section content for everything except the DWARF debug info. The DWARF only exists in the dSYM file. The dSYM file also has all of the symbols as it gets made before the executable is stripped. Many symbols refer to a section by section index, so that is why we must have the section definitions in the dSYM file. So the dSYM wants the sections from the main executable so it can access text and data if needed since symbol refer to these and someone might ask a symbol from a dSYM file what its instructions are. So the dSYM uses the real sections from the main executable file instead of its own.

I see, thanks for the explanation. The code makes more sense now.

But now I have another question. Is this an intentional design decision that we want to preserve; or just how things happen to work now, and should be cleaned up in the future (to achieve the "ObjectFile contains only own sections" invariant)?

Intentional, but it is up to the SymbolVendor subclass to do all of this. We want the data from the dSYM to be useful and since the dSYM really is a companion debug info file, it needs info from elsewhere to be complete.

I'm asking this, because if it's the former then this patch probably needs to be redone, as it tries to enforce that invariant (and then needs to jump through hoops to enable the ObjectFileMachO use case). OTOH, if it's the latter, then I think this is a step in the right direction, as it makes it obvious that ObjectFileMachO is doing something that it shouldn't (and at the same time it makes it harder for other ObjectFiles to do the same).

It should be doing it. Again, the symbol vendor is the one that is trying to make everything fit together and "just work".

BTW, the same situation (symbol file containing empty section definitions for code&data) can happen on elf targets as well (if the symbol file is produced with strip --only-keep-debug), but everything seems to be working fine, presumably because all consumers are accessing the sections through the unified section list.

Exactly. I see any good debug info format not needing to duplicate things that might be in another file. The symbol vendor under the covers, creates a unified experience for all consumers of the Module that contains the symbol vendor, so it is something that we want to encourage and allow. So ObjectFileMachO isn't doing anything wrong. Feel free to update the design if needed?

[clayborg]

AS for the ELF example where only debug info is around, it might not be running into issues if it doesn't contain a symbol table. If it does contain a symbol table, hopefully it is using the unified section table, otherwise if might have symbol's whose addresses have sections from the stripped ELF file and it might not have the section contents that it needs to back it. In that case we might fail to disassemble the symbol's code.

[labath]

In D42955#1026216, @clayborg wrote:

AS for the ELF example where only debug info is around, it might not be running into issues if it doesn't contain a symbol table. If it does contain a symbol table, hopefully it is using the unified section table, otherwise if might have symbol's whose addresses have sections from the stripped ELF file and it might not have the section contents that it needs to back it. In that case we might fail to disassemble the symbol's code.

I made a trivial experiment:

g++ a.cc
objcopy a.out --only-keep-debug a.sym #a.sym contains a symtab
strip a.out # a.out does not contain a symtab
(lldb) target create "a.out"
Current executable set to 'a.out' (x86_64).
(lldb) b main
Breakpoint 1: no locations (pending).
WARNING:  Unable to resolve breakpoint to any actual locations.
(lldb) target symbols add a.sym
symbol file '/tmp/X/a.sym' has been added to '/tmp/X/a.out'
1 location added to breakpoint 1
#symbol resolution seems fine
(lldb) disassemble -n main
a.out`main:
a.out[0x69b] <+0>:  pushq  %rbp
a.out[0x69c] <+1>:  movq   %rsp, %rbp
a.out[0x69f] <+4>:  callq  0x690                     ; foo()
a.out[0x6a4] <+9>:  addl   $0x2a, %eax
a.out[0x6a7] <+12>: popq   %rbp
a.out[0x6a8] <+13>: retq
# so does disassembling

The part that is not clear to me is, if the dsym object file should absorb the sections from the main object file, then what is the purpose of the "unified section list" in the module? I can see why we need a unified list, and I think it's a good idea, but having an ObjectFile containing the merged list seems to defeat it. From a separation of concerns POV, it would be much clearer if each ObjectFile contained only it's own sections, and then some other entity (Module) held the combined data(sections) of the individual object files. Then, most clients should operate on the unified view of the module, but if anyone ever had a reason, he could always look directly at a specific ObjectFile, and see what's contained there.

Among other things, this could be very useful for lldb-server. lldb-server needs only lightweight access to the data in the object file -- it does not need the Module class and everything it pulls in (SymbolVendor, SymbolFile, ...). If we could make the ObjectFile class completely standalone, we can avoid pulling all this stuff in and make the code more modular. It would also help with the migration to llvm's Object parsing library, as it knows nothing about unified sections. If we had a standalone ObjectFile implementation, then it would be easy to swap it out for llvm's and still keep the "section unification" code intact as it would be in a different layer.

So, could this be a direction we can move in? I can put this patch on ice and try to make the ObjectFileMachO standalone instead. I don't think it should be that hard, given that this is how things already work for elf. I'm hoping it will be a matter of changing some consumers to use module->GetSectionList() instead of objfile->GetSectionList()...

[labath]

I don't think this approach is good while ObjectFileMachO is messing with sections of other object files. At this point I think, I've actually learned enough about MachO to understand what the code is doing there, so I'm going to see if I can make it do what I want.

[clayborg]

In D42955#1026296, @labath wrote:

In D42955#1026216, @clayborg wrote:

AS for the ELF example where only debug info is around, it might not be running into issues if it doesn't contain a symbol table. If it does contain a symbol table, hopefully it is using the unified section table, otherwise if might have symbol's whose addresses have sections from the stripped ELF file and it might not have the section contents that it needs to back it. In that case we might fail to disassemble the symbol's code.

I made a trivial experiment:

g++ a.cc
objcopy a.out --only-keep-debug a.sym #a.sym contains a symtab
strip a.out # a.out does not contain a symtab
(lldb) target create "a.out"
Current executable set to 'a.out' (x86_64).
(lldb) b main
Breakpoint 1: no locations (pending).
WARNING:  Unable to resolve breakpoint to any actual locations.
(lldb) target symbols add a.sym
symbol file '/tmp/X/a.sym' has been added to '/tmp/X/a.out'
1 location added to breakpoint 1
#symbol resolution seems fine
(lldb) disassemble -n main
a.out`main:
a.out[0x69b] <+0>:  pushq  %rbp
a.out[0x69c] <+1>:  movq   %rsp, %rbp
a.out[0x69f] <+4>:  callq  0x690                     ; foo()
a.out[0x6a4] <+9>:  addl   $0x2a, %eax
a.out[0x6a7] <+12>: popq   %rbp
a.out[0x6a8] <+13>: retq
# so does disassembling

The part that is not clear to me is, if the dsym object file should absorb the sections from the main object file, then what is the purpose of the "unified section list" in the module? I can see why we need a unified list, and I think it's a good idea, but having an ObjectFile containing the merged list seems to defeat it. From a separation of concerns POV, it would be much clearer if each ObjectFile contained only it's own sections, and then some other entity (Module) held the combined data(sections) of the individual object files. Then, most clients should operate on the unified view of the module, but if anyone ever had a reason, he could always look directly at a specific ObjectFile, and see what's contained there.

The issue is the object file must create symbols that uses the section from the unified section list. The easiest way to accomplish that was to have the object file just use the right section and not have to worry about any other code having to know anything about the relationship between a debuig info file and the main executable file.

Among other things, this could be very useful for lldb-server. lldb-server needs only lightweight access to the data in the object file -- it does not need the Module class and everything it pulls in (SymbolVendor, SymbolFile, ...). If we could make the ObjectFile class completely standalone, we can avoid pulling all this stuff in and make the code more modular. It would also help with the migration to llvm's Object parsing library, as it knows nothing about unified sections. If we had a standalone ObjectFile implementation, then it would be easy to swap it out for llvm's and still keep the "section unification" code intact as it would be in a different layer.

So, could this be a direction we can move in? I can put this patch on ice and try to make the ObjectFileMachO standalone instead. I don't think it should be that hard, given that this is how things already work for elf. I'm hoping it will be a matter of changing some consumers to use module->GetSectionList() instead of objfile->GetSectionList()...

Again, we need any objects coming out of the ObjectFile to have the correct sections. Not sure how we would accomplish that with a solution where the dSYM file uses it own useless sections.

[labath]

In D42955#1027142, @clayborg wrote:

Again, we need any objects coming out of the ObjectFile to have the correct sections. Not sure how we would accomplish that with a solution where the dSYM file uses it own useless sections.

I think we have different definitions of "correct" sections. I agree that the nulled out sections in the dSYM file are (nearly) useless, but I think they are also correct, because that's exactly what's in that object file (and I think a single ObjectFile instance should represent information from a single object file -- nothing more, nothing less). If we need (and we do need) to have a view of combined information from multiple object files, then there should be a separate entity that does that (I think that's what the unified section list is supposed to be). Then, anything that needs to operate on the unified view should be taught to operate on the unified view and not on the individual object files.

Now, I have no idea how hard is it to achieve this, but the fact that this is already how things work for elf gives me hope that it will not be that hard.

Btw, do you know how much I can rely on the test suite to catch any issues here? I've tried simply commenting out the line where we add the section from the unified list into the dsym file, and all tests still passed. Is there any particular scenario I should look at in more detail?

include/lldb/Core/Module.h

public:
   /// symbol files created by the symbol vendor.
   ///
   /// If the symbol vendor has not been loaded yet, this function
   /// will return the section list for the object file.
   ///
   /// @return
   ///     Unified module section list.
   //------------------------------------------------------------------
-  virtual SectionList *GetSectionList();
+  SectionList *GetSectionList();
 
   //------------------------------------------------------------------
   /// Notify the module that the file addresses for the Sections have
   /// been updated.
   ///
   /// If the Section file addresses for a module are updated, this
   /// method should be called.  Any parts of the module, object file,
   /// or symbol file that has cached those file addresses must invalidate
uint32_t ResolveSymbolContextForAddress(lldb::addr_t vm_addr,
                                           Address &so_addr, SymbolContext &sc);
 
   void SymbolIndicesToSymbolContextList(Symtab *symtab,
                                         std::vector<uint32_t> &symbol_indexes,
                                         SymbolContextList &sc_list);
 
   bool SetArchitecture(const ArchSpec &new_arch);
 
-  SectionList *GetUnifiedSectionList();
+  void
+  LoadSymbolVendorAndSectionList(bool can_create = true,
+                                 lldb_private::Stream *feedback_strm = nullptr);
 
   friend class ModuleList;
   friend class ObjectFile;
   friend class SymbolFile;
 
 private:
   Module(); // Only used internally by CreateJITModule ()
 

include/lldb/Symbol/ObjectFile.h

public:
   /// (and object for archives).
   ///
   /// Section list parsing can be deferred by ObjectFile instances
   /// until this accessor is called the first time.
   ///
   /// @return
   ///     The list of sections contained in this object file.
   //------------------------------------------------------------------
-  virtual SectionList *GetSectionList(bool update_module_section_list = true);
-
-  virtual void CreateSections(SectionList &unified_section_list) = 0;
+  virtual SectionList *GetSectionList() = 0;
 
   //------------------------------------------------------------------
   /// Notify the ObjectFile that the file addresses in the Sections
   /// for this module have been changed.
   //------------------------------------------------------------------
   virtual void SectionFileAddressesChanged() {}
 
   //------------------------------------------------------------------

include/lldb/Symbol/SymbolVendor.h

 // Examples would be a subclass that would allow for locating a stand
 // alone debug file, parsing debug maps, or runtime data in the object
 // files. A symbol vendor can use multiple sources (SymbolFile
 // objects) to provide the information and only parse as deep as needed
 // in order to provide the information that is requested.
 //----------------------------------------------------------------------
 class SymbolVendor : public ModuleChild, public PluginInterface {
 public:
+  /// Creates a SymbolVendor plugin for the module_sp argument. The
+  /// unified_list argument is a reference to the unified section list of the
+  /// module and it should be filled out by the symbol vendor before
+  /// constructing the SymbolFile object.
   static SymbolVendor *FindPlugin(const lldb::ModuleSP &module_sp,
+                                  SectionList &unified_list,
                                   Stream *feedback_strm);
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   SymbolVendor(const lldb::ModuleSP &module_sp);
 
   ~SymbolVendor() override;

include/lldb/lldb-private-interfaces.h

typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(
     lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
     const FileSpec *crash_file_path);
 typedef lldb::ScriptInterpreterSP (*ScriptInterpreterCreateInstance)(
     CommandInterpreter &interpreter);
 typedef SymbolFile *(*SymbolFileCreateInstance)(ObjectFile *obj_file);
 typedef SymbolVendor *(*SymbolVendorCreateInstance)(
-    const lldb::ModuleSP &module_sp,
+    const lldb::ModuleSP &module_sp, SectionList &unified_list,
     lldb_private::Stream
         *feedback_strm); // Module can be NULL for default system symbol vendor
 typedef bool (*BreakpointHitCallback)(void *baton,
                                       StoppointCallbackContext *context,
                                       lldb::user_id_t break_id,
                                       lldb::user_id_t break_loc_id);
 typedef bool (*WatchpointHitCallback)(void *baton,
                                       StoppointCallbackContext *context,

lit/Modules/Inputs/stripped.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x00000000004003D0
+Sections:
+  - Name:            .note.gnu.build-id
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000400274
+    AddressAlign:    0x0000000000000004
+    Content:         040000001400000003000000474E55001B8A73AC238390E32A7FF4AC8EBE4D6A41ECF5C9
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x00000000004003D0
+    AddressAlign:    0x0000000000000010
+    Content:         DEADBEEFBAADF00D
+  - Name:            .gnu_debuglink
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000004
+    Content:         38613733616332333833393065333261376666346163386562653464366134316563663563392E646562756700000000ADEE50C1
+...

lit/Modules/Inputs/unstripped.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x00000000004003D0
+Sections:
+  - Name:            .debug_frame
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x0000000000000008
+    Content:         DEADBEEFBAADF00D
+  - Name:            .note.gnu.build-id
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000400274
+    AddressAlign:    0x0000000000000004
+    Content:         040000001400000003000000474E55001B8A73AC238390E32A7FF4AC8EBE4D6A41ECF5C9
+  - Name:            .text
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x00000000004003D0
+    AddressAlign:    0x0000000000000010
+    Size:            0x0000000000000008
+Symbols:
+  Local:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x00000000004003D0
+      Size:            0x0000000000000008
+...

lit/Modules/lit.local.cfg

-config.suffixes = ['.yaml']
+config.suffixes = ['.yaml', '.test']

lit/Modules/unified-section-list.test

+RUN: mkdir -p %t/.build-id/1b
+RUN: yaml2obj %S/Inputs/stripped.yaml > %t/stripped.out
+RUN: yaml2obj %S/Inputs/unstripped.yaml > %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug
+RUN: lldb-test module-sections %t/stripped.out | FileCheck %s
+
+CHECK: Name: .debug_frame
+CHECK-NEXT: VM size: 0
+CHECK-NEXT: File size: 8

lit/lit.cfg

 # the test runner updated.
 execute_external = (platform.system() != 'Windows'
                     or lit_config.getBashPath() not in [None, ""])
 config.test_format = lit.formats.ShTest(execute_external)
 
 # suffixes: We only support unit tests
 config.suffixes = []
 
+config.excludes = ['Inputs']
+
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.lldb_obj_root, 'lit')
 
 # Tweak the PATH to include the tools dir and the scripts dir.
 lldb_tools_dir = config.lldb_tools_dir

source/Core/Module.cpp

size_t Module::FindTypes(
   }
   if (num_matches > 0)
     sc.SortTypeList(typesmap, types);
   return num_matches;
 }
 
 SymbolVendor *Module::GetSymbolVendor(bool can_create,
                                       lldb_private::Stream *feedback_strm) {
+  LoadSymbolVendorAndSectionList(can_create, feedback_strm);
+  return m_symfile_ap.get();
+}
+
+void Module::LoadSymbolVendorAndSectionList(
+    bool can_create, lldb_private::Stream *feedback_strm) {
   if (!m_did_load_symbol_vendor.load()) {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_did_load_symbol_vendor.load() && can_create) {
       ObjectFile *obj_file = GetObjectFile();
       if (obj_file != nullptr) {
+        m_did_load_symbol_vendor = true;
         static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
         Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
-        m_symfile_ap.reset(
-            SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
-        m_did_load_symbol_vendor = true;
+        if (!m_sections_ap)
+          m_sections_ap = llvm::make_unique<SectionList>();
+        m_symfile_ap.reset(SymbolVendor::FindPlugin(
+            shared_from_this(), *m_sections_ap, feedback_strm));
       }
     }
   }
-  return m_symfile_ap.get();
 }
 
 void Module::SetFileSpecAndObjectName(const FileSpec &file,
                                       const ConstString &object_name) {
   // Container objects whose paths do not specify a file directly can call
   // this function to correct the file and object names.
   m_file = file;
   m_mod_time = FileSystem::GetModificationTime(file);
if (!m_did_load_objfile.load()) {
                       GetFileSpec().GetPath().c_str());
         }
       }
     }
   }
   return m_objfile_sp.get();
 }
 
 SectionList *Module::GetSectionList() {
-  // Populate m_unified_sections_ap with sections from objfile.
-  if (!m_sections_ap) {
-    ObjectFile *obj_file = GetObjectFile();
-    if (obj_file != nullptr)
-      obj_file->CreateSections(*GetUnifiedSectionList());
-  }
+  LoadSymbolVendorAndSectionList();
   return m_sections_ap.get();
 }
 
 void Module::SectionFileAddressesChanged() {
   ObjectFile *obj_file = GetObjectFile();
   if (obj_file)
     obj_file->SectionFileAddressesChanged();
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor != nullptr)
     sym_vendor->SectionFileAddressesChanged();
 }
 
-SectionList *Module::GetUnifiedSectionList() {
-  // Populate m_unified_sections_ap with sections from objfile.
-  if (!m_sections_ap)
-    m_sections_ap = llvm::make_unique<SectionList>();
-  return m_sections_ap.get();
-}
-
 const Symbol *Module::FindFirstSymbolWithNameAndType(const ConstString &name,
                                                      SymbolType symbol_type) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
       name.AsCString(), symbol_type);
   SymbolVendor *sym_vendor = GetSymbolVendor();
   if (sym_vendor) {
if (section_list && symbol_file) {
           std::string new_path(file.GetPath());
           std::string old_path(obj_file->GetFileSpec().GetPath());
           if (old_path.find(new_path) == 0) {
             // We specified the same bundle as the symbol file that we already
             // have
             return;
           }
         }
-
-        if (obj_file != m_objfile_sp.get()) {
-          size_t num_sections = section_list->GetNumSections(0);
-          for (size_t idx = num_sections; idx > 0; --idx) {
-            lldb::SectionSP section_sp(
-                section_list->GetSectionAtIndex(idx - 1));
-            if (section_sp->GetObjectFile() == obj_file) {
-              section_list->DeleteSection(idx - 1);
-            }
-          }
-        }
       }
     }
     // Keep all old symbol files around in case there are any lingering type
     // references in
     // any SBValue objects that might have been handed out.
     m_old_symfiles.push_back(std::move(m_symfile_ap));
   }
   m_symfile_spec = file;

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

public:
   uint32_t GetAddressByteSize() const override;
 
   lldb::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
-  void CreateSections(lldb_private::SectionList &unified_section_list) override;
+  lldb_private::SectionList *GetSectionList() override;
 
   void Dump(lldb_private::Stream *s) override;
 
   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   lldb_private::FileSpecList GetDebugSymbolFilePaths() override;

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
   if (!name || !name[0] || !ParseSectionHeaders())
     return 0;
   for (size_t i = 1; i < m_section_headers.size(); ++i)
     if (m_section_headers[i].section_name == ConstString(name))
       return i;
   return 0;
 }
 
-void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
+SectionList *ObjectFileELF::GetSectionList() {
   if (!m_sections_ap.get() && ParseSectionHeaders()) {
     m_sections_ap.reset(new SectionList());
 
     // Object files frequently have 0 for every section address, meaning we
     // need to compute synthetic addresses in order for "file addresses" from
     // different sections to not overlap
     bool synthaddrs = (CalculateType() == ObjectFile::Type::eTypeObjectFile);
     uint64_t nextaddr = 0;
for (SectionHeaderCollIter I = m_section_headers.begin();
           target_bytes_size)); // Number of host bytes per target byte
 
       section_sp->SetPermissions(permissions);
       if (is_thread_specific)
         section_sp->SetIsThreadSpecific(is_thread_specific);
       m_sections_ap->AddSection(section_sp);
     }
   }
-
-  if (m_sections_ap.get()) {
-    if (GetType() == eTypeDebugInfo) {
-      static const SectionType g_sections[] = {
-          eSectionTypeDWARFDebugAbbrev,   eSectionTypeDWARFDebugAddr,
-          eSectionTypeDWARFDebugAranges,  eSectionTypeDWARFDebugCuIndex,
-          eSectionTypeDWARFDebugFrame,    eSectionTypeDWARFDebugInfo,
-          eSectionTypeDWARFDebugLine,     eSectionTypeDWARFDebugLoc,
-          eSectionTypeDWARFDebugMacInfo,  eSectionTypeDWARFDebugPubNames,
-          eSectionTypeDWARFDebugPubTypes, eSectionTypeDWARFDebugRanges,
-          eSectionTypeDWARFDebugStr,      eSectionTypeDWARFDebugStrOffsets,
-          eSectionTypeELFSymbolTable,
-      };
-      SectionList *elf_section_list = m_sections_ap.get();
-      for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]);
-           ++idx) {
-        SectionType section_type = g_sections[idx];
-        SectionSP section_sp(
-            elf_section_list->FindSectionByType(section_type, true));
-        if (section_sp) {
-          SectionSP module_section_sp(
-              unified_section_list.FindSectionByType(section_type, true));
-          if (module_section_sp)
-            unified_section_list.ReplaceSection(module_section_sp->GetID(),
-                                                section_sp);
-          else
-            unified_section_list.AddSection(section_sp);
-        }
-      }
-    } else {
-      unified_section_list = *m_sections_ap;
-    }
-  }
+  return m_sections_ap.get();
 }
 
 // Find the arm/aarch64 mapping symbol character in the given symbol name.
 // Mapping symbols have the
 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping
 // symbol prefixed by
 // an arbitrary string because if a symbol prefix added to each symbol in the
 // object file with

source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
   bool IsExecutable() const override;
 
   uint32_t GetAddressByteSize() const override;
 
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
-  void CreateSections(lldb_private::SectionList &unified_section_list) override;
+  lldb_private::SectionList *GetSectionList() override;
 
   void Dump(lldb_private::Stream *s) override;
 
   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

Symtab *ObjectFileJIT::GetSymtab() {
   }
   return m_symtab_ap.get();
 }
 
 bool ObjectFileJIT::IsStripped() {
   return false; // JIT code that is in a module is never stripped
 }
 
-void ObjectFileJIT::CreateSections(SectionList &unified_section_list) {
+SectionList *ObjectFileJIT::GetSectionList() {
   if (!m_sections_ap.get()) {
     m_sections_ap.reset(new SectionList());
     ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
     if (delegate_sp) {
       delegate_sp->PopulateSectionList(this, *m_sections_ap);
-      unified_section_list = *m_sections_ap;
     }
   }
+  return m_sections_ap.get();
 }
 
 void ObjectFileJIT::Dump(Stream *s) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();

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

public:
   uint32_t GetAddressByteSize() const override;
 
   lldb::AddressClass GetAddressClass(lldb::addr_t file_addr) override;
 
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
-  void CreateSections(lldb_private::SectionList &unified_section_list) override;
+  lldb_private::SectionList *GetSectionList() override;
+
+  /// Create sections for this object file and populate the unified section list
+  /// of the module.
+  void CreateSections(lldb_private::SectionList &unified_section_list);
 
   void Dump(lldb_private::Stream *s) override;
 
   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;

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

if (module_sp) {
       }
     }
   }
   if (m_dysymtab.cmd)
     return m_dysymtab.nlocalsym <= 1;
   return false;
 }
 
+SectionList *ObjectFileMachO::GetSectionList() {
+  if (!m_sections_ap) {
+    // Resolving the module's symbol vendor will populate our section list as
+    // the vendor will call back into the CreateSections funcion below.
+    GetModule()->GetSymbolVendor();
+  }
+  return m_sections_ap.get();
+}
+
 void ObjectFileMachO::CreateSections(SectionList &unified_section_list) {
-  if (!m_sections_ap.get()) {
     m_sections_ap.reset(new SectionList());
 
     const bool is_dsym = (m_header.filetype == MH_DSYM);
     lldb::user_id_t segID = 0;
     lldb::user_id_t sectID = 0;
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     uint32_t i;
     const bool is_core = GetType() == eTypeCoreFile;
for (i = 0; i < m_header.ncmds; ++i) {
       if (load_cmd.cmd == LC_SEGMENT || load_cmd.cmd == LC_SEGMENT_64) {
         if (m_data.GetU8(&offset, (uint8_t *)load_cmd.segname, 16)) {
           bool add_section = true;
           bool add_to_unified = true;
           ConstString const_segname(load_cmd.segname,
                                     std::min<size_t>(strlen(load_cmd.segname),
                                                      sizeof(load_cmd.segname)));
 
           SectionSP unified_section_sp(
               unified_section_list.FindSectionByName(const_segname));
           if (is_dsym && unified_section_sp) {
             if (const_segname == GetSegmentNameLINKEDIT()) {
               // We need to keep the __LINKEDIT segment private to this object
               // file only
               add_to_unified = false;
             } else {
               // This is the dSYM file and this section has already been created
               // by
for (i = 0; i < m_header.ncmds; ++i) {
                   unified_section_sp->SetFileAddress(load_cmd.vmaddr);
 
                   // Notify the module that the section addresses have been
                   // changed once
                   // we're done so any file-address caches can be updated.
                   section_file_addresses_changed = true;
                 }
               }
               m_sections_ap->AddSection(unified_section_sp);
             }
 
             struct section_64 sect64;
             ::memset(&sect64, 0, sizeof(sect64));
             // Push a section into our mach sections for the section at
             // index zero (NO_SECT) if we don't have any mach sections yet...
             if (m_mach_sections.empty())
               m_mach_sections.push_back(sect64);
for (i = 0; i < m_header.ncmds; ++i) {
       }
 
       offset = load_cmd_offset + load_cmd.cmdsize;
     }
 
     if (section_file_addresses_changed && module_sp.get()) {
       module_sp->SectionFileAddressesChanged();
     }
-  }
-}
 
 class MachSymtabSectionInfo {
 public:
   MachSymtabSectionInfo(SectionList *section_list)
       : m_section_list(section_list), m_section_infos() {
     // Get the number of sections down to a depth of 1 to include
     // all segments and their sections, but no other sections that
     // may be added for debug map or

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
 
   //    virtual lldb_private::AddressClass
   //    GetAddressClass (lldb::addr_t file_addr);
 
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
-  void CreateSections(lldb_private::SectionList &unified_section_list) override;
+  lldb_private::SectionList *GetSectionList() override;
 
   void Dump(lldb_private::Stream *s) override;
 
   bool GetArchitecture(lldb_private::ArchSpec &arch) override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

Symtab *ObjectFilePECOFF::GetSymtab() {
   return m_symtab_ap.get();
 }
 
 bool ObjectFilePECOFF::IsStripped() {
   // TODO: determine this for COFF
   return false;
 }
 
-void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) {
+SectionList *ObjectFilePECOFF::GetSectionList() {
   if (!m_sections_ap.get()) {
     m_sections_ap.reset(new SectionList());
 
     ModuleSP module_sp(GetModule());
     if (module_sp) {
       std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
       const uint32_t nsects = m_sect_headers.size();
       ModuleSP module_sp(GetModule());
if (module_sp) {
                 .offset, // Offset to the data for this section in the file
             m_sect_headers[idx]
                 .size, // Size in bytes of this section as found in the file
             m_coff_header_opt.sect_alignment, // Section alignment
             m_sect_headers[idx].flags));      // Flags for this section
 
         // section_sp->SetIsEncrypted (segment_is_encrypted);
 
-        unified_section_list.AddSection(section_sp);
         m_sections_ap->AddSection(section_sp);
       }
     }
   }
+  return m_sections_ap.get();
 }
 
 bool ObjectFilePECOFF::GetUUID(UUID *uuid) { return false; }
 
 uint32_t ObjectFilePECOFF::GetDependentModules(FileSpecList &files) {
   return 0;
 }
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile,
                                        DWARFCompileUnit *dwarf_cu)
     : SymbolFileDWARF(objfile.get()), m_obj_file_sp(objfile),
       m_base_dwarf_cu(dwarf_cu) {
   SetID(((lldb::user_id_t)dwarf_cu->GetOffset()) << 32);
 }
 
 void SymbolFileDWARFDwo::LoadSectionData(lldb::SectionType sect_type,
                                          DWARFDataExtractor &data) {
-  const SectionList *section_list =
-      m_obj_file->GetSectionList(false /* update_module_section_list */);
+  const SectionList *section_list = m_obj_file->GetSectionList();
   if (section_list) {
     SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
     if (section_sp) {
       // See if we memory mapped the DWARF segment?
       if (m_dwarf_data.GetByteSize()) {
         data.SetData(m_dwarf_data, section_sp->GetOffset(),
                      section_sp->GetFileSize());
         return;
assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit "
                                          "called with incompatible compile "
                                          "unit");
   return GetBaseSymbolFile()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
 }
 
 DWARFCompileUnit *SymbolFileDWARFDwo::GetCompileUnit() {
   // A clang module is found via a skeleton CU, but is not a proper DWO.
   // Clang modules have a .debug_info section instead of the *_dwo variant.
-  if (auto *section_list = m_obj_file->GetSectionList(false))
+  if (auto *section_list = m_obj_file->GetSectionList())
     if (auto section_sp =
             section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true))
       if (!section_sp->GetName().GetStringRef().endswith("dwo"))
         return nullptr;
 
   // Only dwo files with 1 compile unit is supported
   if (GetNumCompileUnits() == 1)
     return DebugInfo()->GetCompileUnitAtIndex(0);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.cpp

bool SymbolFileDWARFDwp::LoadRawSectionData(
   if (it != m_sections.end()) {
     if (it->second.GetByteSize() == 0)
       return false;
 
     data = it->second;
     return true;
   }
 
-  const lldb_private::SectionList *section_list =
-      m_obj_file->GetSectionList(false /* update_module_section_list */);
+  const lldb_private::SectionList *section_list = m_obj_file->GetSectionList();
   if (section_list) {
     lldb::SectionSP section_sp(
         section_list->FindSectionByType(sect_type, true));
     if (section_sp) {
       if (m_obj_file->ReadSectionData(section_sp.get(), data) != 0) {
         m_sections[sect_type] = data;
         return true;
       }
     }
   }
   m_sections[sect_type].Clear();
   return false;
 }

source/Plugins/SymbolVendor/ELF/SymbolVendorELF.h

public:
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolVendor *
   CreateInstance(const lldb::ModuleSP &module_sp,
+                 lldb_private::SectionList &unified_list,
                  lldb_private::Stream *feedback_strm);
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 private:
+  lldb_private::SectionList BuildSectionList(lldb_private::ObjectFile &obj);
+
   DISALLOW_COPY_AND_ASSIGN(SymbolVendorELF);
 };
 
 #endif // liblldb_SymbolVendorELF_h_

source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

 // CreateInstance
 //
 // Platforms can register a callback to use when creating symbol
 // vendors to allow for complex debug information file setups, and to
 // also allow for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *
 SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
+                                SectionList &unified_list,
                                 lldb_private::Stream *feedback_strm) {
   if (!module_sp)
     return NULL;
 
   ObjectFile *obj_file = module_sp->GetObjectFile();
   if (!obj_file)
     return NULL;
 
if (dsym_fspec) {
         // This objfile is for debugging purposes. Sadly, ObjectFileELF won't be
         // able
         // to figure this out consistently as the symbol file may not have
         // stripped the
         // code sections, etc.
         dsym_objfile_sp->SetType(ObjectFile::eTypeDebugInfo);
 
         SymbolVendorELF *symbol_vendor = new SymbolVendorELF(module_sp);
-        if (symbol_vendor) {
-          // Get the module unified section list and add our debug sections to
-          // that.
-          SectionList *module_section_list = module_sp->GetSectionList();
-          SectionList *objfile_section_list = dsym_objfile_sp->GetSectionList();
+        unified_list = symbol_vendor->BuildSectionList(*dsym_objfile_sp);
+        symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
+        return symbol_vendor;
+      }
+    }
+  }
+  return NULL;
+}
+
+SectionList SymbolVendorELF::BuildSectionList(ObjectFile &obj) {
+  SectionList UnifiedList = *GetModule()->GetObjectFile()->GetSectionList();
 
-          static const SectionType g_sections[] = {
-              eSectionTypeDWARFDebugAbbrev,   eSectionTypeDWARFDebugAddr,
-              eSectionTypeDWARFDebugAranges,  eSectionTypeDWARFDebugCuIndex,
-              eSectionTypeDWARFDebugFrame,    eSectionTypeDWARFDebugInfo,
-              eSectionTypeDWARFDebugLine,     eSectionTypeDWARFDebugLoc,
-              eSectionTypeDWARFDebugMacInfo,  eSectionTypeDWARFDebugPubNames,
-              eSectionTypeDWARFDebugPubTypes, eSectionTypeDWARFDebugRanges,
-              eSectionTypeDWARFDebugStr,      eSectionTypeDWARFDebugStrOffsets,
-              eSectionTypeELFSymbolTable,
-          };
-          for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]);
-               ++idx) {
-            SectionType section_type = g_sections[idx];
-            SectionSP section_sp(
-                objfile_section_list->FindSectionByType(section_type, true));
-            if (section_sp) {
-              SectionSP module_section_sp(
-                  module_section_list->FindSectionByType(section_type, true));
-              if (module_section_sp)
-                module_section_list->ReplaceSection(module_section_sp->GetID(),
-                                                    section_sp);
-              else
-                module_section_list->AddSection(section_sp);
-            }
-          }
-
-          symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
-          return symbol_vendor;
-        }
-      }
-    }
-  }
-  return NULL;
+  SectionList *SymfileList = obj.GetSectionList();
+
+  static constexpr SectionType g_sections[] = {
+  for (SectionType ST : g_sections) {
+    SectionSP section_sp = SymfileList->FindSectionByType(ST, true);
+    if (!section_sp)
+      continue;
+
+    SectionSP module_section_sp = UnifiedList.FindSectionByType(ST, true);
+      UnifiedList.ReplaceSection(module_section_sp->GetID(), section_sp);
+      UnifiedList.AddSection(section_sp);
+  return UnifiedList;
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 ConstString SymbolVendorELF::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t SymbolVendorELF::GetPluginVersion() { return 1; }

source/Plugins/SymbolVendor/MacOSX/CMakeLists.txt

-include_directories(${LIBXML2_INCLUDE_DIR})
-
 add_lldb_library(lldbPluginSymbolVendorMacOSX PLUGIN
   SymbolVendorMacOSX.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
+    lldbPluginObjectFileMachO
   )

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h

 //===-- SymbolVendorMacOSX.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_SymbolVendorMacOSX_h_
 #define liblldb_SymbolVendorMacOSX_h_
 
+#include "lldb/Core/Section.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/lldb-private.h"
 
 class SymbolVendorMacOSX : public lldb_private::SymbolVendor {
 public:
   //------------------------------------------------------------------
   // Static Functions
   //------------------------------------------------------------------
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolVendor *
   CreateInstance(const lldb::ModuleSP &module_sp,
+                 lldb_private::SectionList &unified_list,
                  lldb_private::Stream *feedback_strm);
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   SymbolVendorMacOSX(const lldb::ModuleSP &module_sp);
 
   virtual ~SymbolVendorMacOSX();
 
   //------------------------------------------------------------------
   // PluginInterface protocol
   //------------------------------------------------------------------
-  virtual lldb_private::ConstString GetPluginName();
+  lldb_private::ConstString GetPluginName() override;
 
-  virtual uint32_t GetPluginVersion();
+  uint32_t GetPluginVersion() override;
 
 private:
+  void BuildUnifiedSectionList(lldb_private::ObjectFile &symfile,
+                               lldb_private::SectionList &unified_list);
+
   DISALLOW_COPY_AND_ASSIGN(SymbolVendorMacOSX);
 };
 
 #endif // liblldb_SymbolVendorMacOSX_h_

source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

 //===-- SymbolVendorMacOSX.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolVendorMacOSX.h"
 
 #include <string.h>
 
+#include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;

 // CreateInstance
 //
 // Platforms can register a callback to use when creating symbol
 // vendors to allow for complex debug information file setups, and to
 // also allow for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *
 SymbolVendorMacOSX::CreateInstance(const lldb::ModuleSP &module_sp,
+                                   SectionList &unified_list,
                                    lldb_private::Stream *feedback_strm) {
   if (!module_sp)
     return NULL;
 
   ObjectFile *obj_file = module_sp->GetObjectFile();
   if (!obj_file)
     return NULL;
 
if (dsym_fspec) {
                     }
                   }
                 }
               }
             }
           }
         }
 
+        symbol_vendor->BuildUnifiedSectionList(*dsym_objfile_sp, unified_list);
         symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
         return symbol_vendor;
       }
     }
 
     // Just create our symbol vendor using the current objfile as this is either
     // an executable with no dSYM (that we could locate), an executable with
     // a dSYM that has a UUID that doesn't match.
+    symbol_vendor->BuildUnifiedSectionList(*obj_file, unified_list);
     symbol_vendor->AddSymbolFileRepresentation(obj_file->shared_from_this());
   }
   return symbol_vendor;
 }
 
+void SymbolVendorMacOSX::BuildUnifiedSectionList(ObjectFile &symfile,
+                                                 SectionList &unified_list) {
+  ObjectFile *objfile = GetModule()->GetObjectFile();
+
+  // Remove any sections which do not belong the the Module's ObjectFile (i.e.,
+  // sections that were placed there by the Module's previous Symbol Vendor).
+  // TODO: Once ObjectFileMachO can create it's own sections without
+  // referencing the unified section list, the next two blocks can be replaced
+  // by:
+  // unified_list = *objfile->GetSections();
+  size_t num_sections = unified_list.GetNumSections(0);
+  for (size_t idx = num_sections; idx > 0; --idx) {
+    lldb::SectionSP section_sp(unified_list.GetSectionAtIndex(idx - 1));
+    if (section_sp->GetObjectFile() != objfile)
+      unified_list.DeleteSection(idx - 1);
+  }
+
+  // If there are no sections in the unified list, it means the main object
+  // file has not had a chance to create them yet. Do it now.
+  if (unified_list.GetNumSections(0) == 0) {
+    static_cast<ObjectFileMachO *>(objfile)->CreateSections(unified_list);
+  }
+
+  // If the symbol file is different from the object file, create the symbol
+  // file sections as well.
+  if (&symfile != GetModule()->GetObjectFile()) {
+    static_cast<ObjectFileMachO &>(symfile).CreateSections(unified_list);
+  }
+}
+
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 ConstString SymbolVendorMacOSX::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t SymbolVendorMacOSX::GetPluginVersion() { return 1; }

source/Symbol/ObjectFile.cpp

if (module_sp) {
     if (log)
       log->Printf("%p ObjectFile::ClearSymtab () symtab = %p",
                   static_cast<void *>(this),
                   static_cast<void *>(m_symtab_ap.get()));
     m_symtab_ap.reset();
   }
 }
 
-SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
-  if (m_sections_ap.get() == nullptr) {
-    if (update_module_section_list) {
-      ModuleSP module_sp(GetModule());
-      if (module_sp) {
-        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-        CreateSections(*module_sp->GetUnifiedSectionList());
-      }
-    } else {
-      SectionList unified_section_list;
-      CreateSections(unified_section_list);
-    }
-  }
-  return m_sections_ap.get();
-}
-
 lldb::SymbolType
 ObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
                                   lldb::SymbolType symbol_type_hint) {
   if (!name.empty()) {
     if (name.startswith("_OBJC_")) {
       // ObjC
       if (name.startswith("_OBJC_CLASS_$_"))
         return lldb::eSymbolTypeObjCClass;

source/Symbol/SymbolFile.cpp

 
 void SymbolFile::PreloadSymbols() {
   // No-op for most implementations.
 }
 
 SymbolFile *SymbolFile::FindPlugin(ObjectFile *obj_file) {
   std::unique_ptr<SymbolFile> best_symfile_ap;
   if (obj_file != nullptr) {
-
-    // We need to test the abilities of this section list. So create what it
-    // would
-    // be with this new obj_file.
-    lldb::ModuleSP module_sp(obj_file->GetModule());
-    if (module_sp) {
-      // Default to the main module section list.
-      ObjectFile *module_obj_file = module_sp->GetObjectFile();
-      if (module_obj_file != obj_file) {
-        // Make sure the main object file's sections are created
-        module_obj_file->GetSectionList();
-        obj_file->CreateSections(*module_sp->GetUnifiedSectionList());
-      }
-    }
-
     // TODO: Load any plug-ins in the appropriate plug-in search paths and
     // iterate over all of them to find the best one for the job.
 
     uint32_t best_symfile_abilities = 0;
 
     SymbolFileCreateInstance create_callback;
     for (uint32_t idx = 0;
          (create_callback = PluginManager::GetSymbolFileCreateCallbackAtIndex(

source/Symbol/SymbolVendor.cpp

 #include "lldb/Symbol/SymbolVendor.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // FindPlugin
 //
 // Platforms can register a callback to use when creating symbol
 // vendors to allow for complex debug information file setups, and to
 // also allow for finding separate debug information files.
 //----------------------------------------------------------------------
 SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
+                                       SectionList &unified_list,
                                        lldb_private::Stream *feedback_strm) {
   std::unique_ptr<SymbolVendor> instance_ap;
   SymbolVendorCreateInstance create_callback;
 
   for (size_t idx = 0;
        (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
             idx)) != nullptr;
        ++idx) {
-    instance_ap.reset(create_callback(module_sp, feedback_strm));
+    instance_ap.reset(create_callback(module_sp, unified_list, feedback_strm));
 
     if (instance_ap.get()) {
       return instance_ap.release();
     }
   }
   // The default implementation just tries to create debug information using the
   // file representation for the module.
   instance_ap.reset(new SymbolVendor(module_sp));
   if (instance_ap.get()) {
     ObjectFile *objfile = module_sp->GetObjectFile();
     if (objfile)
-      instance_ap->AddSymbolFileRepresentation(objfile->shared_from_this());
+      unified_list = *objfile->GetSectionList();
+
   }
   return instance_ap.release();
 }
 
 //----------------------------------------------------------------------
 // SymbolVendor constructor
 //----------------------------------------------------------------------
 SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)

tools/lldb-test/lldb-test.cpp

static void dumpSymbols(Debugger &Dbg) {
   }
 }
 
 static void dumpModules(Debugger &Dbg) {
   LinePrinter Printer(4, llvm::outs());
 
   for (const auto &File : opts::module::InputFilenames) {
     ModuleSpec Spec{FileSpec(File, false)};
-    Spec.GetSymbolFileSpec().SetFile(File, false);
 
     auto ModulePtr = std::make_shared<lldb_private::Module>(Spec);
     SectionList *Sections = ModulePtr->GetSectionList();
     if (!Sections) {
       llvm::errs() << "Could not load sections for module " << File << "\n";
       continue;
     }