Pass Process* along with ObjectFile::GetModuleSpecifications to allow fall back to process's architecture if OS is unknown.

[ovyalov]

Summary

ELF shared object may contain System V OS ABI - i.e., OS part of its architecture triple ends up as unknown.
In this case we cannot fall back to host architecture for remote downloaded modules (e.g. setting i386-apple-macosx for Android modules) .
This CL allows to pass Process pointer along with ObjectFile::GetModuleSpecifications so we can take Vendor and OS information from process architecture if it's not null. Additionally, need to store process as part of Module instance so it can be used to properly deduce architecture upon loading an object file.

[flackr]

LGTM, this gets at least 3 more tests passing when running maxosx -> linux, woohoo!
TestCPPExceptionBreakpoint.py
TestCPPExceptionBreakpoints.py
TestGlobalVariables.py

[clayborg]

We shouldn't pass a process along to any Module, ObjectFile or SymbolFile to determine anything. So this is the wrong fix. Why? Modules can be shared between multiple processes and modules should contain no information that comes from a process.

So the real fix is to:

• Revert this patch
• Fix ObjectFileELF to never use host anything to fill the OS or vendor it, and just not specify anything that it doesn't know for the OS or vendor. If it can't determine the vendor or OS, then leave them as "unspecified unknown".

What is an "unspecified unknown"? This means if you ask the LLVM triple what its OS is:

llvm::Triple::OSType os = llvm_triple.getOS();

it will return an enumeration llvm::Triple::UnknownOS and if you ask the triple for its OS name:

llvm::StringRef os_name = llvm_triple.getOSName();

And unspecified unknown is when the string is empty. A specified unknown is when the user specified "unknown" in the triple or ArchSpec.

It should return an empty string. This is an "unspecified unknown". If you ask a lldb_private::ArchSpec if it is compatible with another, it will answer yes for the following:

ArchSpec arch1("x86_64-apple-ios"); // This will have
ArchSpec arch2("x86_64"); // This will have unspecified unknown values for both the OS and Vendor
ArchSpec arch3("x86_64-unknown-unknown"); // This will have specified unknown values for both the OS and Vendor

// This will be true for the above arch definitions
if (arch1.IsCompatibleMatch(arch2))


// This will be false for the above arch definitions
if (arch1. IsCompatibleMatch(arch3))

So in ObjectFileELF, don't ever use the host to fill anything in, and only specify the vendor and OS if you can figure it out from the contents of the ELF file on its own.

include/lldb/Core/Module.h

1115

Shared libraries can be shared by multiple processes so you can't store any process info in a module. We have gone to great lengths to avoid associating modules with and process or target and I want to keep it that way.

[clayborg]

To further clarify some things: Your target will have an architecture:

ArchSpec target_arch = target.GetArchitecture();

And you will eventually try and load modules for your target and your ELF module might have an architecture that is equivalent to:

ArchSpec module_arch = module->GetArchitecture(); // This will come from the ObjectFileELF

Your module_arch will contain a triple like "x86_64" and will have an unspecified unknown for the OS and vendor. This will be compatible with your target arch so it will allow you to match that module and use it within your target.

If there is any code that is requiring that a Module's OS and vendor to be correctly set, that code will need to be changed to merge the object file arch with the target arch:

void
ModuleFunctionThatMustBeSpecificToATarget (Target *target, ModuleSP module_sp)
{
    ArchSpec arch = module_sp->GetArchitecture();
    arch.MergeFrom(target->GetArchitecture()); // Fill in any gaps in the Module's architecture so that it matches the current process
    ... // Now "arch" is set to have a OS and vendor if it didn't already have one
}

The ArchSpec::MergeFrom will complete the "this" object using info from the argument architecture if anything is an unspecified unknown.

[ovyalov]

Thanks for suggestions and detailed explanation.
Abandoning this CL in favor of http://reviews.llvm.org/D9078

include/lldb/Core/Module.h

 /// representation will only be parsed if the object file is requested
 /// using the Module::GetObjectFile() is called. The debug symbols
 /// will only be parsed if the symbol vendor (SymbolVendor) is
 /// requested using the Module::GetSymbolVendor() is called.
 ///
 /// The module will parse more detailed information as more queries are
 /// made.
 //----------------------------------------------------------------------
+
+class Process;
+
 class Module :
     public std::enable_shared_from_this<Module>,
     public SymbolContextScope
 {
 public:
   // Static functions that can track the lifetime of module objects.
   // This is handy because we might have Module objects that are in
   // shared pointers that aren't in the global module list (from 
// ModuleList). If this is the case we need to know about it.
     ///     multiple architectures).
     //------------------------------------------------------------------
     Module (const FileSpec& file_spec,
             const ArchSpec& arch,
             const ConstString *object_name = NULL,
             lldb::offset_t object_offset = 0,
             const TimeValue *object_mod_time_ptr = NULL);
 
-    Module (const ModuleSpec &module_spec);
-    
+    Module (const ModuleSpec &module_spec, Process *process=nullptr);
     static lldb::ModuleSP
     CreateJITModule (const lldb::ObjectFileJITDelegateSP &delegate_sp);
     
     //------------------------------------------------------------------
     /// Destructor.
     //------------------------------------------------------------------
     virtual 
     ~Module ();
GetSourceMappingList ()
         return m_source_mappings;
     }
     
     const PathMappingList &
     GetSourceMappingList () const
     {
         return m_source_mappings;
     }
-    
+    const lldb::ProcessSP
+    GetProcess () const
+    {
+        return m_process.lock ();
+    }
+
     //------------------------------------------------------------------
     /// 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
protected:
     mutable Mutex               m_mutex;        ///< A mutex to keep this object happy in multi-threaded environments.
     TimeValue                   m_mod_time;     ///< The modification time for this module when it was created.
     ArchSpec                    m_arch;         ///< The architecture for this module.
     UUID                        m_uuid;         ///< Each module is assumed to have a unique identifier to help match it up to debug symbols.
     FileSpec                    m_file;         ///< The file representation on disk for this module (if there is one).
     FileSpec                    m_platform_file;///< The path to the module on the platform on which it is being debugged
     FileSpec                    m_remote_install_file;  ///< If set when debugging on remote platforms, this module will be installed at this location
     FileSpec                    m_symfile_spec; ///< If this path is valid, then this is the file that _will_ be used as the symbol file for this module
+    lldb::ProcessWP             m_process; ///< Optional process reference.
     ConstString                 m_object_name;  ///< The name an object within this module that is selected, or empty of the module is represented by \a m_file.
     uint64_t                    m_object_offset;
     TimeValue                   m_object_mod_time;
     lldb::ObjectFileSP          m_objfile_sp;   ///< A shared pointer to the object file parser for this module as it may or may not be shared with the SymbolFile
     lldb::SymbolVendorUP        m_symfile_ap;   ///< A pointer to the symbol vendor for this module.
     std::vector<lldb::SymbolVendorUP> m_old_symfiles; ///< If anyone calls Module::SetSymbolFileFileSpec() and changes the symbol file,
                                                       ///< we need to keep all old symbol files around in case anyone has type references to them
     lldb::ClangASTContextUP     m_ast;          ///< The AST context for this module.

include/lldb/Symbol/ObjectFile.h

 ///
 /// Object files can be represented by the entire file, or by part of a
 /// file. An example of a partial file ObjectFile is one that contains
 /// information for one of multiple architectures in the same file.
 ///
 /// Once an architecture is selected the object file information can be
 /// extracted from this abstract class.
 //----------------------------------------------------------------------
+
+class Process;
+
 class ObjectFile:
     public std::enable_shared_from_this<ObjectFile>,
     public PluginInterface,
     public ModuleChild
 {
 friend class lldb_private::Module;
 
 public:
public:
 
     //------------------------------------------------------------------
     /// Construct with a parent module, offset, and header data.
     ///
     /// Object files belong to modules and a valid module must be
     /// supplied upon construction. The at an offset within a file for
     /// objects that contain more than one architecture or object.
     //------------------------------------------------------------------
-    ObjectFile (const lldb::ModuleSP &module_sp, 
-                const FileSpec *file_spec_ptr, 
+    ObjectFile (const lldb::ModuleSP &module_sp,
+                const FileSpec *file_spec_ptr,
                 lldb::offset_t file_offset,
                 lldb::offset_t length,
                 const lldb::DataBufferSP& data_sp,
                 lldb::offset_t data_offset);
 
     ObjectFile (const lldb::ModuleSP &module_sp, 
                 const lldb::ProcessSP &process_sp,
                 lldb::addr_t header_addr, 
FindPlugin (const lldb::ModuleSP &module_sp,
                 lldb::addr_t header_addr,
                 lldb::DataBufferSP &file_data_sp);
 
     
     static size_t
     GetModuleSpecifications (const FileSpec &file,
                              lldb::offset_t file_offset,
                              lldb::offset_t file_size,
+                             Process* process,
                              ModuleSpecList &specs);
     
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t file_size,
+                             Process* process,
                              lldb_private::ModuleSpecList &specs);
     //------------------------------------------------------------------
     /// Split a path into a file path with object name.
     ///
     /// For paths like "/tmp/foo.a(bar.o)" we often need to split a path
     /// up into the actual path name and into the object name so we can
     /// make a valid object file from it.
     ///

include/lldb/Target/Platform.h

private:
         GetRemoteSharedModule (const ModuleSpec &module_spec,
                                Process* process,
                                lldb::ModuleSP &module_sp,
                                const ModuleResolver &module_resolver,
                                bool *did_create_ptr);
 
         bool
         GetCachedSharedModule (const ModuleSpec& module_spec,
+                               Process* process,
                                lldb::ModuleSP &module_sp,
                                bool *did_create_ptr);
 
         Error
         LoadCachedExecutable (const ModuleSpec &module_spec,
                               lldb::ModuleSP &module_sp,
                               const FileSpecList *module_search_paths_ptr,
                               Platform &remote_platform);

include/lldb/lldb-private-interfaces.h

 
 namespace lldb_private
 {
     typedef lldb::ABISP (*ABICreateInstance) (const ArchSpec &arch);
     typedef Disassembler* (*DisassemblerCreateInstance) (const ArchSpec &arch, const char *flavor);
     typedef DynamicLoader* (*DynamicLoaderCreateInstance) (Process* process, bool force);
     typedef lldb::JITLoaderSP (*JITLoaderCreateInstance) (Process *process, bool force);
     typedef ObjectContainer* (*ObjectContainerCreateInstance) (const lldb::ModuleSP &module_sp, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t offset, lldb::offset_t length);
-    typedef size_t (*ObjectFileGetModuleSpecifications) (const FileSpec &file, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, ModuleSpecList &module_specs);
+    typedef size_t (*ObjectFileGetModuleSpecifications) (const FileSpec &file, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, Process* process, ModuleSpecList &module_specs);
     typedef ObjectFile* (*ObjectFileCreateInstance) (const lldb::ModuleSP &module_sp, lldb::DataBufferSP& data_sp, lldb::offset_t data_offset, const FileSpec* file, lldb::offset_t file_offset, lldb::offset_t length);
     typedef ObjectFile* (*ObjectFileCreateMemoryInstance) (const lldb::ModuleSP &module_sp, lldb::DataBufferSP& data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t offset);
     typedef bool (*ObjectFileSaveCore) (const lldb::ProcessSP &process_sp, const FileSpec &outfile, Error &error);
     typedef LogChannel* (*LogChannelCreateInstance) ();
     typedef EmulateInstruction * (*EmulateInstructionCreateInstance) (const ArchSpec &arch, InstructionType inst_type);
     typedef OperatingSystem* (*OperatingSystemCreateInstance) (Process *process, bool force);
     typedef LanguageRuntime *(*LanguageRuntimeCreateInstance) (Process *process, lldb::LanguageType language);
     typedef SystemRuntime *(*SystemRuntimeCreateInstance) (Process *process);

source/API/SBModuleSpec.cpp

 }
 
 SBModuleSpecList
 SBModuleSpecList::GetModuleSpecifications (const char *path)
 {
     SBModuleSpecList specs;
     FileSpec file_spec(path, true);
     Host::ResolveExecutableInBundle(file_spec);
-    ObjectFile::GetModuleSpecifications(file_spec, 0, 0, *specs.m_opaque_ap);
+    ObjectFile::GetModuleSpecifications(file_spec, 0, 0, nullptr, *specs.m_opaque_ap);
     return specs;
 }
 
 void
 SBModuleSpecList::Append (const SBModuleSpec &spec)
 {
     m_opaque_ap->Append (*spec.m_opaque_ap);
 }

source/Commands/CommandObjectTarget.cpp

AddModuleSymbols (Target *target,
             // that can be used for a module that might exist in the
             // current target, so we need to find that module in the
             // target
             ModuleList matching_module_list;
 
             size_t num_matches = 0;
             // First extract all module specs from the symbol file
             lldb_private::ModuleSpecList symfile_module_specs;
-            if (ObjectFile::GetModuleSpecifications(module_spec.GetSymbolFileSpec(), 0, 0, symfile_module_specs))
+            if (ObjectFile::GetModuleSpecifications(module_spec.GetSymbolFileSpec(), 0, 0, nullptr, symfile_module_specs))
             {
                 // Now extract the module spec that matches the target architecture
                 ModuleSpec target_arch_module_spec;
                 ModuleSpec symfile_module_spec;
                 target_arch_module_spec.GetArchitecture() = target->GetArchitecture();
                 if (symfile_module_specs.FindMatchingModuleSpec(target_arch_module_spec, symfile_module_spec))
                 {
                     // See if it has a UUID?

source/Core/Module.cpp

DumpModuleInfo (void)
                     (uint32_t)module->use_count(), 
                     strm.GetString().c_str());
         }
     }
 }
 
 #endif
 
-Module::Module (const ModuleSpec &module_spec) :
+Module::Module (const ModuleSpec &module_spec, Process *process) :
     m_mutex (Mutex::eMutexTypeRecursive),
     m_mod_time (),
     m_arch (),
     m_uuid (),
     m_file (),
     m_platform_file(),
     m_remote_install_file(),
     m_symfile_spec (),
if (log)
         log->Printf ("%p Module::Module((%s) '%s%s%s%s')",
                      static_cast<void*>(this),
                      module_spec.GetArchitecture().GetArchitectureName(),
                      module_spec.GetFileSpec().GetPath().c_str(),
                      module_spec.GetObjectName().IsEmpty() ? "" : "(",
                      module_spec.GetObjectName().IsEmpty() ? "" : module_spec.GetObjectName().AsCString(""),
                      module_spec.GetObjectName().IsEmpty() ? "" : ")");
 
+    if (process)
+    {
+        m_process = process->shared_from_this();
+    }
     // First extract all module specifications from the file using the local
     // file path. If there are no specifications, then don't fill anything in
     ModuleSpecList modules_specs;
-    if (ObjectFile::GetModuleSpecifications(module_spec.GetFileSpec(), 0, 0, modules_specs) == 0)
+    if (ObjectFile::GetModuleSpecifications(module_spec.GetFileSpec(), 0, 0, process, modules_specs) == 0)
         return;
 
     // Now make sure that one of the module specifications matches what we just
     // extract. We might have a module specification that specifies a file "/usr/lib/dyld"
     // with UUID XXX, but we might have a local version of "/usr/lib/dyld" that has
     // UUID YYY and we don't want those to match. If they don't match, just don't
     // fill any ivars in so we don't accidentally grab the wrong file later since
     // they don't match...

source/Host/common/Symbols.cpp

for (size_t idx = 0; idx < num_directories; ++idx)
             FileSpec file_spec (filename.c_str(), true);
 
             if (llvm::sys::fs::equivalent (file_spec.GetPath(), module_spec.GetFileSpec().GetPath()))
                 continue;
 
             if (file_spec.Exists())
             {
                 lldb_private::ModuleSpecList specs;
-                const size_t num_specs = ObjectFile::GetModuleSpecifications (file_spec, 0, 0, specs);
+                const size_t num_specs = ObjectFile::GetModuleSpecifications (file_spec, 0, 0, nullptr, specs);
                 assert (num_specs <= 1 && "Symbol Vendor supports only a single architecture");
                 if (num_specs == 1)
                 {
                     ModuleSpec mspec;
                     if (specs.GetModuleSpecAtIndex (0, mspec))
                     {
                         if (mspec.GetUUID() == module_uuid)
                             return file_spec;

source/Host/linux/Host.cpp

 static bool
 GetELFProcessCPUType (const char *exe_path, ProcessInstanceInfo &process_info)
 {
     // Clear the architecture.
     process_info.GetArchitecture().Clear();
 
     ModuleSpecList specs;
     FileSpec filespec (exe_path, false);
-    const size_t num_specs = ObjectFile::GetModuleSpecifications (filespec, 0, 0, specs);
+    const size_t num_specs = ObjectFile::GetModuleSpecifications (filespec, 0, 0, nullptr, specs);
     // GetModuleSpecifications() could fail if the executable has been deleted or is locked.
     // But it shouldn't return more than 1 architecture.
     assert(num_specs <= 1 && "Linux plugin supports only a single architecture");
     if (num_specs == 1)
     {
         ModuleSpec module_spec;
         if (specs.GetModuleSpecAtIndex (0, module_spec) && module_spec.GetArchitecture().IsValid())
         {

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

CreateInstance (const lldb::ModuleSP &module_sp,
                     lldb::offset_t length);
 
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
 
     static bool
     MagicBytesMatch (const lldb_private::DataExtractor &data);
 
     //------------------------------------------------------------------
     // Member Functions
     //------------------------------------------------------------------

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 
 
 size_t
 ObjectContainerBSDArchive::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                                     lldb::DataBufferSP& data_sp,
                                                     lldb::offset_t data_offset,
                                                     lldb::offset_t file_offset,
                                                     lldb::offset_t file_size,
+                                                    lldb_private::Process* process,
                                                     lldb_private::ModuleSpecList &specs)
 {
 
     // We have data, which means this is the first 512 bytes of the file
     // Check to see if the magic bytes match and if they do, read the entire
     // table of contents for the archive and cache it
     DataExtractor data;
     data.SetData (data_sp, data_offset, data_sp->GetByteSize());
if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data))
                 if (object)
                 {
                     const lldb::offset_t object_file_offset = file_offset + object->ar_file_offset;
                     if (object->ar_file_offset < file_size && file_size > object_file_offset)
                     {
                         if (ObjectFile::GetModuleSpecifications(file,
                                                                 object_file_offset,
                                                                 file_size - object_file_offset,
+                                                                process,
                                                                 specs))
                         {
                             ModuleSpec &spec = specs.GetModuleSpecRefAtIndex (specs.GetSize() - 1);
                             TimeValue object_mod_time;
                             object_mod_time.OffsetWithSeconds(object->ar_date);
                             spec.GetObjectName () = object->ar_name;
                             spec.SetObjectOffset (object_file_offset);
                             spec.SetObjectSize (file_size - object_file_offset);

source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h

CreateInstance (const lldb::ModuleSP &module_sp,
                     lldb::offset_t length);
 
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
 
     static bool
     MagicBytesMatch (const lldb_private::DataExtractor &data);
 
     //------------------------------------------------------------------
     // Member Functions
     //------------------------------------------------------------------

source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

 
 
 size_t
 ObjectContainerUniversalMachO::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                                         lldb::DataBufferSP& data_sp,
                                                         lldb::offset_t data_offset,
                                                         lldb::offset_t file_offset,
                                                         lldb::offset_t file_size,
+                                                        lldb_private::Process* process,
                                                         lldb_private::ModuleSpecList &specs)
 {
     const size_t initial_count = specs.GetSize();
     
     DataExtractor data;
     data.SetData (data_sp, data_offset, data_sp->GetByteSize());
 
     if (ObjectContainerUniversalMachO::MagicBytesMatch(data))
     {
         llvm::MachO::fat_header header;
         std::vector<llvm::MachO::fat_arch> fat_archs;
         if (ParseHeader (data, header, fat_archs))
         {
             for (const llvm::MachO::fat_arch &fat_arch : fat_archs)
             {
                 const lldb::offset_t slice_file_offset = fat_arch.offset + file_offset;
                 if (fat_arch.offset < file_size && file_size > slice_file_offset)
                 {
                     ObjectFile::GetModuleSpecifications (file,
                                                          slice_file_offset,
                                                          file_size - slice_file_offset,
+                                                         process,
                                                          specs);
                 }
             }
         }
     }
     return specs.GetSize() - initial_count;
 }
 

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

CreateMemoryInstance (const lldb::ModuleSP &module_sp,
                           lldb::addr_t header_addr);
 
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
 
     static bool
     MagicBytesMatch (lldb::DataBufferSP& data_sp,
                      lldb::addr_t offset, 
                      lldb::addr_t length);
 
     //------------------------------------------------------------------
private:
     size_t
     ParseSectionHeaders();
 
     /// Parses the elf section headers and returns the uuid, debug link name, crc, archspec.
     static size_t
     GetSectionHeaderInfo(SectionHeaderColl &section_headers,
                          lldb_private::DataExtractor &data,
                          const elf::ELFHeader &header,
+                         lldb_private::Process* process,
                          lldb_private::UUID &uuid,
                          std::string &gnu_debuglink_file,
                          uint32_t &gnu_debuglink_crc,
                          lldb_private::ArchSpec &arch_spec);
 
     /// Scans the dynamic section and locates all dependent modules (shared
     /// libraries) populating m_filespec_ap.  This method will compute the
     /// dependent module list only once.  Returns the number of dependent

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MathExtras.h"
 

 }
 
 size_t
 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                         lldb::DataBufferSP& data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
+                                        lldb_private::Process* process,
                                         lldb_private::ModuleSpecList &specs)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
 
     const size_t initial_count = specs.GetSize();
 
     if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
     {
if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
                         data.SetData(data_sp);
                     }
 
                     uint32_t gnu_debuglink_crc = 0;
                     std::string gnu_debuglink_file;
                     SectionHeaderColl section_headers;
                     lldb_private::UUID &uuid = spec.GetUUID();
 
-                    GetSectionHeaderInfo(section_headers, data, header, uuid, gnu_debuglink_file, gnu_debuglink_crc, spec.GetArchitecture ());
+                    GetSectionHeaderInfo(section_headers, data, header, process, uuid, gnu_debuglink_file, gnu_debuglink_crc, spec.GetArchitecture ());
 
                     // If the module vendor is not set and the module OS matches this host OS, set the module vendor to the host vendor.
                     llvm::Triple &spec_triple = spec.GetArchitecture ().GetTriple ();
                     if (spec_triple.getVendor () == llvm::Triple::VendorType::UnknownVendor)
                     {
                         const llvm::Triple &host_triple = HostInfo::GetArchitecture().GetTriple();
                         if (spec_triple.getOS () == host_triple.getOS ())
                             spec_triple.setVendor (host_triple.getVendor ());

 
 //----------------------------------------------------------------------
 // GetSectionHeaderInfo
 //----------------------------------------------------------------------
 size_t
 ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
                                     lldb_private::DataExtractor &object_data,
                                     const elf::ELFHeader &header,
+                                    lldb_private::Process* process,
                                     lldb_private::UUID &uuid,
                                     std::string &gnu_debuglink_file,
                                     uint32_t &gnu_debuglink_crc,
                                     ArchSpec &arch_spec)
 {
     // Don't reparse the section headers if we already did that.
     if (!section_headers.empty())
         return section_headers.size();
 
     // Only initialize the arch_spec to okay defaults if they're not already set.
     // We'll refine this with note data as we parse the notes.
     if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS)
     {
         const uint32_t sub_type = subTypeFromElfHeader(header);
         arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, sub_type);
 
+        if (process && process->GetTarget ().GetArchitecture ().GetCore () == arch_spec.GetCore ())
+        {
+            const auto& proc_arch = process->GetTarget ().GetArchitecture ().GetTriple ();
+            arch_spec.GetTriple ().setOS(proc_arch.getOS ());
+            arch_spec.GetTriple ().setVendor(proc_arch.getVendor ());
+        }
+        else
+        {
             switch (arch_spec.GetAddressByteSize())
             {
             case 4:
                 {
                     const ArchSpec host_arch32 = HostInfo::GetArchitecture(HostInfo::eArchKind32);
                     if (host_arch32.GetCore() == arch_spec.GetCore())
                     {
                         arch_spec.GetTriple().setOSName(HostInfo::GetOSString().data());
                         arch_spec.GetTriple().setVendorName(HostInfo::GetVendorString().data());
                     }
                 }
                 break;
             case 8:
                 {
                     const ArchSpec host_arch64 = HostInfo::GetArchitecture(HostInfo::eArchKind64);
                     if (host_arch64.GetCore() == arch_spec.GetCore())
                     {
                         arch_spec.GetTriple().setOSName(HostInfo::GetOSString().data());
                         arch_spec.GetTriple().setVendorName(HostInfo::GetVendorString().data());
                     }
                 }
                 break;
             }
         }
+    }
 
     // If there are no section headers we are done.
     if (header.e_shnum == 0)
         return 0;
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
 
     section_headers.resize(header.e_shnum);

 }
 
 //----------------------------------------------------------------------
 // ParseSectionHeaders
 //----------------------------------------------------------------------
 size_t
 ObjectFileELF::ParseSectionHeaders()
 {
-    return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
+    const auto process_sp = m_process_wp.lock ();
+    return GetSectionHeaderInfo(
+        m_section_headers, m_data, m_header, process_sp.get (), m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
 }
 
 const ObjectFileELF::ELFSectionHeaderInfo *
 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id)
 {
     if (!id || !ParseSectionHeaders())
         return NULL;
 

source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

CreateMemoryInstance (const lldb::ModuleSP &module_sp,
                           lldb::addr_t header_addr);
 
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
     
     //------------------------------------------------------------------
     // Member Functions
     //------------------------------------------------------------------
     ObjectFileJIT (const lldb::ModuleSP &module_sp,
                    const lldb::ObjectFileJITDelegateSP &delegate_sp);
     

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

 }
 
 size_t
 ObjectFileJIT::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                         lldb::DataBufferSP& data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
+                                        lldb_private::Process* process,
                                         lldb_private::ModuleSpecList &specs)
 {
     // JIT'ed object file can't be read from a file on disk
     return 0;
 }
 
 ObjectFileJIT::ObjectFileJIT (const lldb::ModuleSP &module_sp,
                               const ObjectFileJITDelegateSP &delegate_sp) :

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

CreateMemoryInstance (const lldb::ModuleSP &module_sp,
                           lldb::addr_t header_addr);
 
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
 
     static bool
     SaveCore (const lldb::ProcessSP &process_sp,
               const lldb_private::FileSpec &outfile,
               lldb_private::Error &error);
 
     static bool

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

 }
 
 size_t
 ObjectFileMachO::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                           lldb::DataBufferSP& data_sp,
                                           lldb::offset_t data_offset,
                                           lldb::offset_t file_offset,
                                           lldb::offset_t length,
+                                          lldb_private::Process* process,
                                           lldb_private::ModuleSpecList &specs)
 {
     const size_t initial_count = specs.GetSize();
     
     if (ObjectFileMachO::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
     {
         DataExtractor data;
         data.SetData(data_sp);

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

CreateMemoryInstance (const lldb::ModuleSP &module_sp,
                           lldb::addr_t header_addr);
     
     static size_t
     GetModuleSpecifications (const lldb_private::FileSpec& file,
                              lldb::DataBufferSP& data_sp,
                              lldb::offset_t data_offset,
                              lldb::offset_t file_offset,
                              lldb::offset_t length,
+                             lldb_private::Process* process,
                              lldb_private::ModuleSpecList &specs);
 
     static bool
     MagicBytesMatch (lldb::DataBufferSP& data_sp);
     
     
     ObjectFilePECOFF (const lldb::ModuleSP &module_sp,
                       lldb::DataBufferSP& data_sp,

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 }
 
 size_t
 ObjectFilePECOFF::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                            lldb::DataBufferSP& data_sp,
                                            lldb::offset_t data_offset,
                                            lldb::offset_t file_offset,
                                            lldb::offset_t length,
+                                           lldb_private::Process* process,
                                            lldb_private::ModuleSpecList &specs)
 {
     const size_t initial_count = specs.GetSize();
 
     if (ObjectFilePECOFF::MagicBytesMatch(data_sp))
     {
         DataExtractor data;
         data.SetData(data_sp, data_offset, length);

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

GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
     packet.GetHexByteString(triple);
     ArchSpec arch(triple.c_str());
 
     const FileSpec req_module_path_spec(module_path.c_str(), true);
     const FileSpec module_path_spec = FindModuleFile(req_module_path_spec.GetPath(), arch);
     const ModuleSpec module_spec(module_path_spec, arch);
 
     ModuleSpecList module_specs;
-    if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0, module_specs))
+    if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0, nullptr, module_specs))
         return SendErrorResponse (3);
 
     ModuleSpec matched_module_spec;
     if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
         return SendErrorResponse (4);
 
     const auto file_offset = matched_module_spec.GetObjectOffset();
     const auto file_size = matched_module_spec.GetObjectSize();

source/Symbol/ObjectFile.cpp

ObjectFile::FindPlugin (const lldb::ModuleSP &module_sp,
     object_file_sp.reset();
     return object_file_sp;
 }
 
 size_t
 ObjectFile::GetModuleSpecifications (const FileSpec &file,
                                      lldb::offset_t file_offset,
                                      lldb::offset_t file_size,
+                                     Process* process,
                                      ModuleSpecList &specs)
 {
     DataBufferSP data_sp (file.ReadFileContents(file_offset, 512));
     if (data_sp)
     {
         if (file_size == 0)
         {
             const lldb::offset_t actual_file_size = file.GetByteSize();
             if (actual_file_size > file_offset)
                 file_size = actual_file_size - file_offset;
         }
         return ObjectFile::GetModuleSpecifications (file,       // file spec
                                                     data_sp,    // data bytes
                                                     0,          // data offset
                                                     file_offset,// file offset
                                                     file_size,  // file length
+                                                    process,  // process - can be null
                                                     specs);
     }
     return 0;
 }
 
 size_t
 ObjectFile::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                      lldb::DataBufferSP& data_sp,
                                      lldb::offset_t data_offset,
                                      lldb::offset_t file_offset,
                                      lldb::offset_t file_size,
+                                     Process* process,
                                      lldb_private::ModuleSpecList &specs)
 {
     const size_t initial_count = specs.GetSize();
     ObjectFileGetModuleSpecifications callback;
     uint32_t i;
     // Try the ObjectFile plug-ins
     for (i = 0; (callback = PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(i)) != nullptr; ++i)
     {
-        if (callback (file, data_sp, data_offset, file_offset, file_size, specs) > 0)
+        if (callback (file, data_sp, data_offset, file_offset, file_size, process, specs) > 0)
             return specs.GetSize() - initial_count;
     }
 
     // Try the ObjectContainer plug-ins
     for (i = 0; (callback = PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) != nullptr; ++i)
     {
-        if (callback (file, data_sp, data_offset, file_offset, file_size, specs) > 0)
+        if (callback (file, data_sp, data_offset, file_offset, file_size, process, specs) > 0)
             return specs.GetSize() - initial_count;
     }
     return 0;
 }
 
 ObjectFile::ObjectFile (const lldb::ModuleSP &module_sp,
                         const FileSpec *file_spec_ptr,
                         lldb::offset_t file_offset,
                         lldb::offset_t length,
                         const lldb::DataBufferSP& data_sp,
                         lldb::offset_t data_offset
 ) :
     ModuleChild (module_sp),
     m_file (),  // This file could be different from the original module's file
     m_type (eTypeInvalid),
     m_strata (eStrataInvalid),
     m_file_offset (file_offset),
     m_length (length),
     m_data (),
     m_unwind_table (*this),
-    m_process_wp(),
+    m_process_wp(module_sp->GetProcess ()),
     m_memory_addr (LLDB_INVALID_ADDRESS),
     m_sections_ap(),
     m_symtab_ap ()
 {
     if (file_spec_ptr)
         m_file = *file_spec_ptr;
     if (data_sp)
         m_data.SetData (data_sp, data_offset, length);

source/Target/Platform.cpp

 }
 
 bool
 Platform::GetModuleSpec (const FileSpec& module_file_spec,
                          const ArchSpec& arch,
                          ModuleSpec &module_spec)
 {
     ModuleSpecList module_specs;
-    if (ObjectFile::GetModuleSpecifications (module_file_spec, 0, 0, module_specs) == 0)
+    if (ObjectFile::GetModuleSpecifications (module_file_spec, 0, 0, nullptr, module_specs) == 0)
         return false;
 
     ModuleSpec matched_module_spec;
     return module_specs.FindMatchingModuleSpec (ModuleSpec (module_file_spec, arch),
                                                 module_spec);
 }
 
 PlatformSP
if (!got_module_spec)
         if (!GetModuleSpec (module_spec.GetFileSpec (), module_spec.GetArchitecture (), resolved_module_spec))
             return module_resolver (module_spec);
     }
 
     // Trying to find a module by UUID on local file system.
     const auto error = module_resolver (resolved_module_spec);
     if (error.Fail ())
      {
-          if (GetCachedSharedModule (resolved_module_spec, module_sp, did_create_ptr))
+          if (GetCachedSharedModule (resolved_module_spec, process, module_sp, did_create_ptr))
               return Error ();
      }
 
     return error;
 }
 
 bool
 Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
+                                 Process* process,
                                  lldb::ModuleSP &module_sp,
                                  bool *did_create_ptr)
 {
     if (IsHost() ||
         !GetGlobalPlatformProperties ()->GetUseModuleCache ())
         return false;
 
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
auto error = m_module_cache->GetAndPut (
 
             tmp_download_file_spec.SetFile (tmp_download_file_path.c_str (), true);
             return DownloadModuleSlice (module_spec.GetFileSpec (),
                                         module_spec.GetObjectOffset (),
                                         module_spec.GetObjectSize (),
                                         tmp_download_file_spec);
 
         },
+        process,
         module_sp,
         did_create_ptr);
     if (error.Success ())
         return true;
 
     if (log)
         log->Printf("Platform::%s - module %s not found in local cache: %s",
                     __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());

source/Target/TargetList.cpp

if (user_exe_path && user_exe_path[0])
         module_spec.GetFileSpec().SetFile(user_exe_path, true);
         
         // Resolve the executable in case we are given a path to a application bundle
         // like a .app bundle on MacOSX
         Host::ResolveExecutableInBundle (module_spec.GetFileSpec());
 
         lldb::offset_t file_offset = 0;
         lldb::offset_t file_size = 0;
-        const size_t num_specs = ObjectFile::GetModuleSpecifications (module_spec.GetFileSpec(), file_offset, file_size, module_specs);
+        const size_t num_specs = ObjectFile::GetModuleSpecifications (module_spec.GetFileSpec(), file_offset, file_size, nullptr, module_specs);
         if (num_specs > 0)
         {
             ModuleSpec matching_module_spec;
 
             if (num_specs == 1)
             {
                 if (module_specs.GetModuleSpecAtIndex(0, matching_module_spec))
                 {

source/Utility/ModuleCache.h

 
 #include <functional>
 #include <string>
 #include <unordered_map>
 
 namespace lldb_private {
 
 class Module;
+class Process;
 class UUID;
 
 //----------------------------------------------------------------------
 /// @class ModuleCache ModuleCache.h "Utility/ModuleCache.h"
 /// @brief A module cache class.
 ///
 /// Caches locally modules that are downloaded from remote targets.
 /// Each cached module maintains 2 views:
Put (const FileSpec &root_dir_spec,
          const char *hostname,
          const ModuleSpec &module_spec,
          const FileSpec &tmp_file);
 
     Error
     Get (const FileSpec &root_dir_spec,
          const char *hostname,
          const ModuleSpec &module_spec,
+         Process* process,
          lldb::ModuleSP &cached_module_sp,
          bool *did_create_ptr);
 
     Error
     GetAndPut(const FileSpec &root_dir_spec,
               const char *hostname,
               const ModuleSpec &module_spec,
               const Downloader &downloader,
+              Process* process,
               lldb::ModuleSP &cached_module_sp,
               bool *did_create_ptr);
 
 private:
     static FileSpec
     GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid);
 
     static FileSpec

source/Utility/ModuleCache.cpp

ModuleCache::Put (const FileSpec &root_dir_spec,
     const auto sysroot_module_path_spec = GetHostSysRootModulePath (root_dir_spec, hostname, module_spec.GetFileSpec ());
     return CreateHostSysRootModuleSymLink (sysroot_module_path_spec, module_file_path);
 }
 
 Error
 ModuleCache::Get (const FileSpec &root_dir_spec,
                   const char *hostname,
                   const ModuleSpec &module_spec,
+                  Process* process,
                   ModuleSP &cached_module_sp,
                   bool *did_create_ptr)
 {
     const auto find_it = m_loaded_modules.find (module_spec.GetUUID ().GetAsString());
     if (find_it != m_loaded_modules.end ())
     {
         cached_module_sp = (*find_it).second.lock ();
         if (cached_module_sp)
ModuleCache::Get (const FileSpec &root_dir_spec,
     const auto sysroot_module_path_spec = GetHostSysRootModulePath (root_dir_spec, hostname, module_spec.GetFileSpec ());
     if (!sysroot_module_path_spec.Exists ())
         CreateHostSysRootModuleSymLink (sysroot_module_path_spec, module_spec.GetFileSpec ());
 
     auto cached_module_spec (module_spec);
     cached_module_spec.GetUUID ().Clear ();  // Clear UUID since it may contain md5 content hash instead of real UUID.
     cached_module_spec.GetFileSpec () = module_file_path;
     cached_module_spec.GetPlatformFileSpec () = module_spec.GetFileSpec ();
-    cached_module_sp.reset (new Module (cached_module_spec));
+    cached_module_sp.reset (new Module (cached_module_spec, process));
     if (did_create_ptr)
         *did_create_ptr = true;
 
     m_loaded_modules.insert (std::make_pair (module_spec.GetUUID ().GetAsString (), cached_module_sp));
 
     return Error ();
 }
 
 Error
 ModuleCache::GetAndPut (const FileSpec &root_dir_spec,
                         const char *hostname,
                         const ModuleSpec &module_spec,
                         const Downloader &downloader,
+                        Process* process,
                         lldb::ModuleSP &cached_module_sp,
                         bool *did_create_ptr)
 {
     // Check local cache for a module.
     auto error = Get (root_dir_spec,
                       hostname,
                       module_spec,
+                      process,
                       cached_module_sp,
                       did_create_ptr);
     if (error.Success ())
         return error;
 
     FileSpec tmp_download_file_spec;
     error = downloader (module_spec, tmp_download_file_spec);
     llvm::FileRemover tmp_file_remover (tmp_download_file_spec.GetPath ().c_str ());
     if (error.Fail ())
         return Error("Failed to download module: %s", error.AsCString ());
 
     // Put downloaded file into local module cache.
     error = Put (root_dir_spec,
                  hostname,
                  module_spec,
                  tmp_download_file_spec);
     if (error.Fail ())
         return Error ("Failed to put module into cache: %s", error.AsCString ());
 
     return Get (root_dir_spec,
                 hostname,
                 module_spec,
+                process,
                 cached_module_sp,
                 did_create_ptr);
 }
 
 FileSpec
 ModuleCache::GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid)
 {
     const auto modules_dir_spec = JoinPath (root_dir_spec, kModulesSubdir);