Update ObjectFileELF to detect ELF triple based on ELF notes and the ELF header.

[tfiala]

Summary

This change modifies how ObjectFileELF determines the architecture of an ELF file. It no longer assumes the elf file's vendor and OS is the same as the current host. It is one step in supporting running lldb across MacOSX/Linux/FreeBSD/NetBSD.

The current ELF note parsing added supports checking for a FreeBSD, Linux, and NetBSD ABI note. If found, the OS is set appropriately. The previously-existing GNU UUID note parsing code has been incorporated into the broader note-parsing code provided here.

[tfiala]

Hang on - just caught a couple member variables that are not in the initializer list. Will add a new diff in a few minutes with all members properly in the initializer list.

[tfiala]

There were quite a few members not in the constructor initializer list. Added those there, ran the tests on Linux, all clean.

Ed - the second (complete) diff is fine to look at now.

[emaste]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1075

n_name is a std::string and the length (namesz) should be handled in the note parser so you should be able to just do note.n_name == LLDB_NT_OWNER_FREEBSD, no?

Also for the purpose of this parsing we'll generally have just one case in each of the switch statements - maybe it'd be more concise to just check note.n_type == LLDB_NT_FREEBSD_ABI_TAG in the if() as well?

[emaste]

Hmm, I just tried w/ a core file I have around, and it seems we correctly get the triple but then fail:

main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' module OSABI: ELFOSABI_FREEBSD
main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' set ELF module OS type from ELF header OSABI.
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=1
main-thread ObjectFileELF::RefineModuleDetailsFromNote detected FreeBSD, min version constant 1100021
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=2
main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' module set to triple: x86_64-unknown-freebsd (architecture x86_64)
main-thread 0x80926b600 Module::Module((x86_64) '/bin/sleep')
main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' module OSABI: ELFOSABI_FREEBSD
main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' set ELF module OS type from ELF header OSABI.
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=1
main-thread ObjectFileELF::RefineModuleDetailsFromNote detected FreeBSD, min version constant 1100021
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=2
main-thread ObjectFileELF::GetModuleSpecifications file '/bin/sleep' module set to triple: x86_64-unknown-freebsd (architecture x86_64)
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=1
main-thread ObjectFileELF::RefineModuleDetailsFromNote detected FreeBSD, min version constant 1100021
main-thread ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=2
main-thread Target::Target created with architecture x86_64 (x86_64-unknown-freebsd)
main-thread 0x80926c000 Module::Module((x86_64) 'libc.so.7')
main-thread 0x80926c000 Module::~Module((unknown) '')
main-thread 0x80926c000 Module::Module((x86_64) '/data/emaste/src/llvm/build/sleep.core')
main-thread ObjectFileELF::GetModuleSpecifications file '/data/emaste/src/llvm/build/sleep.core' module OSABI: ELFOSABI_FREEBSD
main-thread ObjectFileELF::GetModuleSpecifications file '/data/emaste/src/llvm/build/sleep.core' set ELF module OS type from ELF header OSABI.
main-thread ObjectFileELF::GetModuleSpecifications file '/data/emaste/src/llvm/build/sleep.core' module set to triple: x86_64-unknown-freebsd (architecture x86_64)
main-thread 0x80926c000 Module::~Module((x86_64) '/data/emaste/src/llvm/build/sleep.core')
main-thread Went to stop the private state thread, but it was already invalid.
error: Unable to find process plug-in for core file '/data/emaste/src/llvm/build/sleep.core'

Looking into it...

[tfiala]

error: Unable to find process plug-in for core file '/data/emaste/src/llvm/build/sleep.core'
Looking into it...

Hey Ed,

I'm not sure how you were doing the entire setup above, but here's what I need to do on the MacOSX side when debugging a Linux exe (over llgs):

// Enable some logging
log enable -T -f /tmp/xcode_gdbremote.log gdb-remote packets process
log enable -T -f /tmp/xcode_module.log lldb module

// Syncing over files from my Mac box to my Linux box
platform shell rsync -av /Users/tfiala/play/loop_test tfiala2.mtv.corp.google.com:play

// This obviously only works in the llgs branch for now, but: fire up llgs
platform shell ssh tfiala2.mtv.corp.google.com 'lldb/macosx.sync/git-s02-macpro/build-debug/bin/lldb-gdbserver --log-file /tmp/llgs.log --lldb-command "log enable -T -f /tmp/llgs.log lldb process host" --lldb-command "log enable -T -f /tmp/llgs_packets.log gdb-remote packets" tfiala-macpro.mtv.corp.google.com:1234' &

// This may be the critical part you're missing - se the platform for whatever ELF object files you were trying to load. The --sysroot part shows where I have my linux root filesystem mapped locally on the MacOSX side so that things like libc.so can be found.
platform select --sysroot /Volumes/tfiala2.mtv.corp.google.com remote-linux

// And then create the target for the given architecture
target create --arch x86_64-pc-linux /Users/tfiala/play/loop_test/bin/linux-x86_64/main --remote-file /usr/local/google/home/tfiala/play/loop_test/bin/linux-x86_64/main

// GDB remote in.
gdb-remote tfiala2.mtv.corp.google.com:1234

// Set a breakpoint.
b main.cpp:10

// And go.
run

Those LLDB commands represent how I'm able to successfully run a Linux x86_64 Linux ELF (2.6.26 ABI IIRC, from Ubuntu 12.04 LTS) on the llgs side and somewhat play with it on the MacOSX side.

It's possible there are little bits that the llgs branch has in it that are making this more possible. I did not try running from FreeBSD to a Linux llgs side.

These ObjectFileELF changes were necessary to get to the point where I could do a "(lldb) file /some/elf/from/other/platform" to show up right with an "(lldb) image list -t -f" command.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1075

Also for the purpose of this parsing we'll generally have just one case in each of the switch statements - maybe it'd be more concise to just check note.n_type == LLDB_NT_FREEBSD_ABI_TAG in the if() as well?

Sure, I think it's only GNU that is using multiple ones. I can change that for the others.

n_name is a std::string and the length (namesz) should be handled in the note parser so you should be able to just do note.n_name == LLDB_NT_OWNER_FREEBSD, no?

Yes, but I was looking to avoid the string compare if the length wasn't equal. That would stop needing to get the string length of the constant. Overall this is likely very minor compared to the cost of scanning the entire contents though, so probably worth the simplification.

[emaste]

I'm not sure how you were doing the entire setup above

This wasn't using llgs at all, just the local core file support

bin/lldb /bin/sleep -c sleep.core

Last night I discovered that the triple is x86_64-unknown-freebsd with the patch, and x86_64-unknown-freebsd10.0 without. The latter matches the platform triple reported by platform status.

With the patch, in ModuleList::GetSharedModule the module_sp->GetObjectFile() fails.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1075

Yes, but I was looking to avoid the string compare if the length wasn't equal. That would stop needing to get the string length of the constant. Overall this is likely very minor compared to the cost of scanning the entire contents though, so probably worth the simplification.

Oh, good point. I was probably reading something else into it from my previous investigations into ELF notes and having to deal with a special case for the Linux core note n_namesz.

[tfiala]

Last night I discovered that the triple is x86_64-unknown-freebsd with the patch, and x86_64-unknown-freebsd10.0 without. The latter matches the platform triple reported by platform status.

Interesting. I'll need to get that to correspond.

I'm adjusting the triple with llvm::Triple::setOS(). I don't see a llvm::Triple::OSType for FreeBSD10.0? (i.e. is it not possible to build that triple with the llvm code? Shouldn't it be? Maybe the OS version somehow needs to get appended on that - looking at the details of Triple now...)

Hey Ed - how do I interpret the payload 32-bit value that comes with the OS ABI part?

Also - I have a cleaned up patch coming soon that adjusts for some other comments you had.

[tfiala]

Hey Ed - how do I interpret the payload 32-bit value that comes with the OS ABI part?

Specifically, for the FREEBSD ABI note.

[tfiala]

Hey Ed,

It looks like the FreeBSD ABI note contains a release date? If that's right, any idea on the best way to convert that to a FreeBSD version number? We could use a table of release dates and find an exact match or, if not a match, the first release date that comes before the given date.

I'll wait for you to tell me more about that note. There might be a better way to get the version number on FreeBSD for elf. Seems a little crazy to parse it out of a release date.

[tfiala]

BTW - I was looking here:
http://lists.freebsd.org/pipermail/freebsd-current/2009-January/001939.html

to try to figure out what it was. The comments make it look like an os release date. When interpreted as a decimal integer, it almost looks like it's encoding something more useful like a 10 with some other (maj/min/dot info?) shifted by a few factors of 10.

[tfiala]

I've got a patch coming up that will support this, Ed. You'll want to adjust (or tell me what to adjust) that does this:
tfiala-macpro:lldb tfiala$ DerivedData/lldb/Build/Products/Debug/lldb
(lldb) file /tmp/ls-freebsd
Current executable set to '/tmp/ls-freebsd' (x86_64).
(lldb) image list -b -t
[ 0] ls-freebsd x86_64-unknown-freebsd10.0
(lldb)

[tfiala]

Updated for comments from Ed Maste re: string usage, case usage on single case, and freebsd OS name setting.

Requires a change to really parse out the FreeBSD version from the FreeBSD ABI ELF note payload.

[emaste]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

210

I think this should be fine (and will test in a moment):
version_major = version_info / 100000;
version_minor = (version_info / 1000) % 100;

But something's odd with LLDB's FreeBSD platform triples - it reports -freebsd10.0 on my FreeBSD 11-current laptop, and -freebsd9.1 on my FreeBSD 9.2 desktop.

[tfiala]

It's called osreldate but is actually the version information - for
example, on my desktop running FreeBSD 9.2-STABLE branch:
+-+-+-+-+-+-+-+

9	0 2	5 0 9

+-+-+-+-+-+-+-+
Maj Min Rxx

Ok cool - that gives me everything I need. So for me down below, it would be Maj = 10, Min = 0, Rxx is 510.

<lldb.driver.main-thread> ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=1
<lldb.driver.main-thread> ObjectFileELF::RefineModuleDetailsFromNote detected FreeBSD, min version constant 1000510

I'll update the patch for that.

[emaste]

Also for the purpose of this parsing we'll generally have just one case in each of the switch statements - maybe it'd be more concise to just check note.n_type == LLDB_NT_FREEBSD_ABI_TAG in the if() as well?

Sure, I think it's only GNU that is using multiple ones. I can change that for the others.

Yeah - I was just hoping to lessen the bloat a bit for future
additions -- I suspect later ones will be (n_name == OpenBSD && n_type

OPENBSD_ABI_TAG), n_name == DragonFly && n_type

DRAGONFLY_ABI_TAG), etc.. all following the same pattern.

[tfiala]

With this patch, I get the following loading a FreeBSD 10.0.510 elf object file:

tfiala-macpro:lldb tfiala$ DerivedData/lldb/Build/Products/Debug/lldb
(lldb) log enable lldb modules
(lldb) file /tmp/ls-freebsd
...
<lldb.driver.main-thread> ObjectFileELF::RefineModuleDetailsFromNote parsing note name='FreeBSD', type=1
<lldb.driver.main-thread> ObjectFileELF::RefineModuleDetailsFromNote detected FreeBSD 10.0.510
...
Current executable set to '/tmp/ls-freebsd' (x86_64).
(lldb) image list -b -t
[ 0] ls-freebsd x86_64-unknown-freebsd10.0
(lldb)

[emaste]

It turns out this still fails in some cases, as it seems somewhere in
ModuleList::GetSharedModule's call of module_sp->GetObjectFile there's
an exact match on the platform triple string. On FreeBSD the platform
triple ends up as e.g. "x86_64-unknown-freebsd9.1" (with the version
appended), and the version is detected at cmake run time.

I'm not sure what the right fix is.

a) Add code to Host::GetArchitecture() to strip the version off
(returning x86_64-unknown-freebsd), and going back to the earlier
version of the FreeBSD ABI note handling.
b) Change the match to compare only the Arch and OS.
c) Something else?

[tfiala]

It turns out this still fails in some cases, as it seems somewhere in
ModuleList::GetSharedModule's call of module_sp->GetObjectFile there's
an exact match on the platform triple string. On FreeBSD the platform
triple ends up as e.g. "x86_64-unknown-freebsd9.1" (with the version
appended), and the version is detected at cmake run time.

So with the latest patch, it isn't always computing x86_64-unknown-freebsd9.1 in your case for the ObjectFileELF object file? It would be great to find out where the non-versioned x86_64-unknown-freebsd was coming from in that case.

[emaste]

So with the latest patch, it isn't always computing x86_64-unknown-freebsd9.1 in your case for the ObjectFileELF object file? It would be great to find out where the non-versioned x86_64-unknown-freebsd was coming from in that case.

With the patch it correctly reports "x86_64-unknown-freebsd9.2." The
problem is that the triple reported by the platform plugin is
"x86_64-unknown-freebsd9.1" and it doesn't match.

[tfiala]

Ok, thanks for explaining.

I'd be in favor of eliminating the dependence on the version number of the OS. If there is a reason that becomes important, I suspect there will be other parts we'll need to address as well since the version check might need to be something like: OS version must be >= some min ABI version to do something. So the version number seems too specific to have in the triple.

[tfiala]

I'm going to remove this part from the llgs branch and not focus on cross-architecture debugging for the initial llgs upstream. This clearly needs a little more time to work out a situation that doesn't break FreeBSD. I was primarily working on this since it was a necessary part to enabling cross Linux/MacOSX lldb/llgs to work (Linux x86_64 llgs with MacOSX lldb). But that element is not critical for getting llgs Linux x86_64 upstreamed.

[emaste]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2565

After a lengthy debugging session it turns out this is the change that breaks core file loading on FreeBSD. The core file has no sections (the core data and thread / register notes are in program segments), so ParseSectionHeaders() returns 0.

[tfiala]

After a lengthy debugging session it turns out this is the change that breaks core file loading on FreeBSD. The core file has no sections (the core data and thread / register notes are in program segments), so ParseSectionHeaders() returns 0.

Oh dang. I originally had a comment on that in the first version of the patch to draw attention to whether that was valid or not to have no sections. I ultimately removed the comment.

Okay - so I can easily just call the method. Of course, if there are no sections, it also won't pick up the notes either. Is this a case where its creating a module on the fly?

[tfiala]

Hey Ed,

This patch fixes the ParseHeaders() with a zero return value so that it does not fail out the GetArchitecture() call.

Let me know if that gets you further.

We'll still need to figure out how to adjust the code to not require a FreeBSD version number (or adjust how the version number is set properly across the board).

[emaste]

Thanks Todd - this works on FreeBSD now.

I must have been mistaken in part of my earlier analysis; based on my test now and Greg's description of the triple comparison it looks like it is actually done by matching the Arch and OS, not the string.

[emaste]

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1101

Should we validate that the descsz is as expected in here too? E.g. (note.n_name == LLDB_NT_OWNER_FREEBSD && note.n_type == LLDB_NT_FREEBSD_ABI_TAG && note.n_descsz == 4)

[tfiala]

I'll go ahead and adjust for the size check in the FreeBSD ABI tag and do the same for NetBSD.

Thanks for testing, Ed! Glad to get this in.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1101

I could do that. It will fail either way if it's less than the expected size (i.e. if we go down the path of processing a note with an owner of LLDB_NT_OWNER_FREEBSD and a note type of LLDB_NT_FREEBSD_ABI_TAG) since the read will fail.

It might be worth putting a warning in the code if the size doesn't match expectations - that way we'd at least be able to track down what was breaking if we found the note but it didn't match size expectations. (i.e. effectively a change in the note definition or a broken code emitter).

[emaste]

Thanks Todd, I'm very happy to see this go in!

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

1101

I was thinking of the other case. if the size recorded in the file is larger than the data. We'd then partially consume the payload and then try to read a subsequent ELF note from the wrong location, no?

[tfiala]

This went in here, with minor tweaks to test note size and a test to verify that Linux and FreeBSD x86_64 image architecture/triple types are reported correctly:

svn commit
Sending source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
Sending source/Plugins/ObjectFile/ELF/ObjectFileELF.h
Adding test/functionalities/object-file
Adding test/functionalities/object-file/TestImageListMultiArchitecture.py
Adding (bin) test/functionalities/object-file/ls-freebsd-10.0-x86_64
Adding (bin) test/functionalities/object-file/sleep-ubuntu-14.04-x86_64
Transmitting file data .....
Committed revision 211907.

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Core/UUID.h"
+#include "lldb/Core/ArchSpec.h"
 
 #include "ELFHeader.h"
 

     /// Cached value of the entry point for this module.
     lldb_private::Address  m_entry_point_address;
 
+    /// The architecture detected from parsing elf file contents.
+    lldb_private::ArchSpec m_arch_spec;
+
     /// Returns a 1 based index of the given section header.
     size_t
     SectionIndex(const SectionHeaderCollIter &I);

     size_t
     ParseSectionHeaders();
 
-    /// Parses the elf section headers and returns the uuid, debug link name, crc.
+    /// 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::UUID &uuid,
                          std::string &gnu_debuglink_file,
-                         uint32_t &gnu_debuglink_crc);
+                         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

         
     unsigned
     PLTRelocationType();
+
+    static lldb_private::Error
+    RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid);
 };
 
 #endif // #ifndef liblldb_ObjectFileELF_h_

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 using namespace llvm::ELF;
 
 namespace {
+
+// ELF note owner definitions
+const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
+const char *const LLDB_NT_OWNER_GNU     = "GNU";
+const char *const LLDB_NT_OWNER_NETBSD  = "NetBSD";
+
+// ELF note type definitions
+const elf_word LLDB_NT_FREEBSD_ABI_TAG  = 0x01;
+const elf_word LLDB_NT_GNU_ABI_TAG      = 0x01;
+const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;
+const elf_word LLDB_NT_NETBSD_ABI_TAG   = 0x01;
+
+// GNU ABI note OS constants
+const elf_word LLDB_NT_GNU_ABI_OS_LINUX   = 0x00;
+const elf_word LLDB_NT_GNU_ABI_OS_HURD    = 0x01;
+const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;
+
 //===----------------------------------------------------------------------===//
 /// @class ELFRelocation
 /// @brief Generic wrapper for ELFRel and ELFRela.

     return core_notes_crc;
 }
 
+static const char*
+OSABIAsCString (unsigned char osabi_byte)
+{
+#define _MAKE_OSABI_CASE(x) case x: return #x
+    switch (osabi_byte)
+    {
+        _MAKE_OSABI_CASE(ELFOSABI_NONE);
+        _MAKE_OSABI_CASE(ELFOSABI_HPUX);
+        _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
+        _MAKE_OSABI_CASE(ELFOSABI_GNU);
+        _MAKE_OSABI_CASE(ELFOSABI_HURD);
+        _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
+        _MAKE_OSABI_CASE(ELFOSABI_AIX);
+        _MAKE_OSABI_CASE(ELFOSABI_IRIX);
+        _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
+        _MAKE_OSABI_CASE(ELFOSABI_TRU64);
+        _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
+        _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
+        _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
+        _MAKE_OSABI_CASE(ELFOSABI_NSK);
+        _MAKE_OSABI_CASE(ELFOSABI_AROS);
+        _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
+        _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
+        _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
+        _MAKE_OSABI_CASE(ELFOSABI_ARM);
+        _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
+        default:
+            return "<unknown-osabi>";
+    }
+#undef _MAKE_OSABI_CASE
+}
+
+static bool
+GetOsFromOSABI (unsigned char osabi_byte, llvm::Triple::OSType &ostype)
+{
+    switch (osabi_byte)
+    {
+        case ELFOSABI_AIX:      ostype = llvm::Triple::OSType::AIX; break;
+        case ELFOSABI_FREEBSD:  ostype = llvm::Triple::OSType::FreeBSD; break;
+        case ELFOSABI_GNU:      ostype = llvm::Triple::OSType::Linux; break;
+        case ELFOSABI_NETBSD:   ostype = llvm::Triple::OSType::NetBSD; break;
+        case ELFOSABI_OPENBSD:  ostype = llvm::Triple::OSType::OpenBSD; break;
+        case ELFOSABI_SOLARIS:  ostype = llvm::Triple::OSType::Solaris; break;
+        default:
+            ostype = llvm::Triple::OSType::UnknownOS;
+    }
+    return ostype != llvm::Triple::OSType::UnknownOS;
+}
+
 size_t
 ObjectFileELF::GetModuleSpecifications (const lldb_private::FileSpec& file,
                                         lldb::DataBufferSP& data_sp,

                                         lldb::offset_t length,
                                         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()))

                                                        LLDB_INVALID_CPUTYPE);
                 if (spec.GetArchitecture().IsValid())
                 {
-                    // We could parse the ABI tag information (in .note, .notes, or .note.ABI-tag) to get the
-                    // machine information. However, this info isn't guaranteed to exist or be correct. Details:
-                    //  http://refspecs.linuxfoundation.org/LSB_1.2.0/gLSB/noteabitag.html
-                    // Instead of passing potentially incorrect information down the pipeline, grab
-                    // the host information and use it.
-                    spec.GetArchitecture().GetTriple().setOSName (Host::GetOSString().GetCString());
-                    spec.GetArchitecture().GetTriple().setVendorName(Host::GetVendorString().GetCString());
+                    llvm::Triple::OSType ostype;
+                    // First try to determine the OS type from the OSABI field in the elf header.
 
+                    if (log)
+                        log->Printf ("ObjectFileELF::%s file '%s' module OSABI: %s", __FUNCTION__, file.GetPath ().c_str (), OSABIAsCString (header.e_ident[EI_OSABI]));
+                    if (GetOsFromOSABI (header.e_ident[EI_OSABI], ostype) && ostype != llvm::Triple::OSType::UnknownOS)
+                    {
+                        spec.GetArchitecture ().GetTriple ().setOS (ostype);
+
+                        // Also clear the vendor so we don't end up with situations like
+                        // x86_64-apple-FreeBSD.
+                        spec.GetArchitecture ().GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+
+                        if (log)
+                            log->Printf ("ObjectFileELF::%s file '%s' set ELF module OS type from ELF header OSABI.", __FUNCTION__, file.GetPath ().c_str ());
+                    }
+
                     // Try to get the UUID from the section list. Usually that's at the end, so
                     // map the file in if we don't have it already.
                     size_t section_header_end = header.e_shoff + header.e_shnum * header.e_shentsize;

                     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);
 
+                    GetSectionHeaderInfo(section_headers, data, header, 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 = Host::GetArchitecture ().GetTriple ();
+                        if (spec_triple.getOS () == host_triple.getOS ())
+                            spec_triple.setVendor (host_triple.getVendor ());
+                    }
+
+                    if (log)
+                        log->Printf ("ObjectFileELF::%s file '%s' module set to triple: %s (architecture %s)", __FUNCTION__, file.GetPath ().c_str (), spec_triple.getTriple ().c_str (), spec.GetArchitecture ().GetArchitectureName ());
+
                     if (!uuid.IsValid())
                     {
                         uint32_t core_notes_crc = 0;

                               lldb::offset_t length) : 
     ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
     m_header(),
+    m_uuid(),
+    m_gnu_debuglink_file(),
+    m_gnu_debuglink_crc(0),
     m_program_headers(),
     m_section_headers(),
-    m_filespec_ap()
+    m_dynamic_symbols(),
+    m_filespec_ap(),
+    m_entry_point_address(),
+    m_arch_spec()
 {
     if (file)
         m_file = *file;
     ::memset(&m_header, 0, sizeof(m_header));
-    m_gnu_debuglink_crc = 0;
-    m_gnu_debuglink_file.clear();
 }
 
 ObjectFileELF::ObjectFileELF (const lldb::ModuleSP &module_sp,

                               addr_t header_addr) :
     ObjectFile(module_sp, process_sp, LLDB_INVALID_ADDRESS, data_sp),
     m_header(),
+    m_uuid(),
+    m_gnu_debuglink_file(),
+    m_gnu_debuglink_crc(0),
     m_program_headers(),
     m_section_headers(),
-    m_filespec_ap()
+    m_dynamic_symbols(),
+    m_filespec_ap(),
+    m_entry_point_address(),
+    m_arch_spec()
 {
     ::memset(&m_header, 0, sizeof(m_header));
 }

     return GetProgramHeaderInfo(m_program_headers, m_data, m_header);
 }
 
-static bool
-ParseNoteGNUBuildID(DataExtractor &data, lldb_private::UUID &uuid)
+lldb_private::Error
+ObjectFileELF::RefineModuleDetailsFromNote (lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid)
 {
-    // Try to parse the note section (ie .note.gnu.build-id|.notes|.note|...) and get the build id.
-    // BuildID documentation: https://fedoraproject.org/wiki/Releases/FeatureBuildId
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
+    Error error;
+
     lldb::offset_t offset = 0;
-    static const uint32_t g_gnu_build_id = 3; // NT_GNU_BUILD_ID from elf.h
 
     while (true)
     {
+        // Parse the note header.  If this fails, bail out.
         ELFNote note = ELFNote();
         if (!note.Parse(data, &offset))
-            return false;
+        {
+            // We're done.
+            return error;
+        }
 
-        // 16 bytes is UUID|MD5, 20 bytes is SHA1
-        if (note.n_name == "GNU" && (note.n_type == g_gnu_build_id) &&
-            (note.n_descsz == 16 || note.n_descsz == 20))
+        // If a tag processor handles the tag, it should set processed to true, and
+        // the loop will assume the tag processing has moved entirely past the note's payload.
+        // Otherwise, leave it false and the end of the loop will handle the offset properly.
+        bool processed = false;
+
+        if (log)
+            log->Printf ("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, __FUNCTION__, note.n_name.c_str (), note.n_type);
+
+        // Process FreeBSD ELF notes.
+        if (note.n_name == LLDB_NT_OWNER_FREEBSD)
         {
-            uint8_t uuidbuf[20]; 
-            if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == NULL)
-                return false;
-            uuid.SetBytes (uuidbuf, note.n_descsz);
-            return true;
+            if (note.n_type == LLDB_NT_FREEBSD_ABI_TAG)
+            {
+                // We'll consume the payload below.
+                processed = true;
+
+                // Pull out the min version info.
+                uint32_t version_info;
+                if (data.GetU32 (&offset, &version_info, 1) == nullptr)
+                {
+                    error.SetErrorString ("failed to read FreeBSD ABI note payload");
+                    return error;
+                }
+
+                // Convert the version info into a major/minor number.
+                const uint32_t version_major = version_info / 100000;
+                const uint32_t version_minor = (version_info / 1000) % 100;
+
+                char os_name[32];
+                snprintf (os_name, sizeof (os_name), "freebsd%" PRIu32 ".%" PRIu32, version_major, version_minor);
+
+                // Set the elf OS version to FreeBSD.  Also clear the vendor.
+                arch_spec.GetTriple ().setOSName (os_name);
+                arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+
+                if (log)
+                    log->Printf ("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_major, version_minor, static_cast<uint32_t> (version_info % 1000));
+            }
         }
-        offset += llvm::RoundUpToAlignment(note.n_descsz, 4);
+        // Process GNU ELF notes.
+        else if (note.n_name == LLDB_NT_OWNER_GNU)
+        {
+            switch (note.n_type)
+            {
+                case LLDB_NT_GNU_ABI_TAG:
+                    {
+                        // We'll consume the payload below.
+                        processed = true;
+
+                        // Pull out the min OS version supporting the ABI.
+                        uint32_t version_info[4];
+                        if (data.GetU32 (&offset, &version_info[0], note.n_descsz / 4) == nullptr)
+                        {
+                            error.SetErrorString ("failed to read GNU ABI note payload");
+                            return error;
+                        }
+
+                        // Set the OS per the OS field.
+                        switch (version_info[0])
+                        {
+                            case LLDB_NT_GNU_ABI_OS_LINUX:
+                                arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Linux);
+                                arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+                                if (log)
+                                    log->Printf ("ObjectFileELF::%s detected Linux, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]);
+                                // FIXME we have the minimal version number, we could be propagating that.  version_info[1] = OS Major, version_info[2] = OS Minor, version_info[3] = Revision.
+                                break;
+                            case LLDB_NT_GNU_ABI_OS_HURD:
+                                arch_spec.GetTriple ().setOS (llvm::Triple::OSType::UnknownOS);
+                                arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+                                if (log)
+                                    log->Printf ("ObjectFileELF::%s detected Hurd (unsupported), min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]);
+                                break;
+                            case LLDB_NT_GNU_ABI_OS_SOLARIS:
+                                arch_spec.GetTriple ().setOS (llvm::Triple::OSType::Solaris);
+                                arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+                                if (log)
+                                    log->Printf ("ObjectFileELF::%s detected Solaris, min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[1], version_info[2], version_info[3]);
+                                break;
+                            default:
+                                if (log)
+                                    log->Printf ("ObjectFileELF::%s unrecognized OS in note, id %" PRIu32 ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, __FUNCTION__, version_info[0], version_info[1], version_info[2], version_info[3]);
+                                break;
+                        }
+                    }
+                    break;
+
+                case LLDB_NT_GNU_BUILD_ID_TAG:
+                    // Only bother processing this if we don't already have the uuid set.
+                    if (!uuid.IsValid())
+                    {
+                        // We'll consume the payload below.
+                        processed = true;
+
+                        // 16 bytes is UUID|MD5, 20 bytes is SHA1
+                        if ((note.n_descsz == 16 || note.n_descsz == 20))
+                        {
+                            uint8_t uuidbuf[20];
+                            if (data.GetU8 (&offset, &uuidbuf, note.n_descsz) == nullptr)
+                            {
+                                error.SetErrorString ("failed to read GNU_BUILD_ID note payload");
+                                return error;
+                            }
+
+                            // Save the build id as the UUID for the module.
+                            uuid.SetBytes (uuidbuf, note.n_descsz);
+                        }
+                    }
+                    break;
+            }
+        }
+        // Process NetBSD ELF notes.
+        else if (note.n_name == LLDB_NT_OWNER_NETBSD)
+        {
+            if (note.n_type == LLDB_NT_NETBSD_ABI_TAG)
+            {
+
+                // We'll consume the payload below.
+                processed = true;
+
+                // Pull out the min version info.
+                uint32_t version_info;
+                if (data.GetU32 (&offset, &version_info, 1) == nullptr)
+                {
+                    error.SetErrorString ("failed to read NetBSD ABI note payload");
+                    return error;
+                }
+
+                // Set the elf OS version to NetBSD.  Also clear the vendor.
+                arch_spec.GetTriple ().setOS (llvm::Triple::OSType::NetBSD);
+                arch_spec.GetTriple ().setVendor (llvm::Triple::VendorType::UnknownVendor);
+
+                if (log)
+                    log->Printf ("ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32, __FUNCTION__, version_info);
+            }
+        }
+        // Add other OS version notes here.
+
+        if (!processed)
+            offset += llvm::RoundUpToAlignment(note.n_descsz, 4);
     }
-    return false;
+
+    return error;
 }
 
+
 //----------------------------------------------------------------------
 // GetSectionHeaderInfo
 //----------------------------------------------------------------------

                                     const elf::ELFHeader &header,
                                     lldb_private::UUID &uuid,
                                     std::string &gnu_debuglink_file,
-                                    uint32_t &gnu_debuglink_crc)
+                                    uint32_t &gnu_debuglink_crc,
+                                    ArchSpec &arch_spec)
 {
+    // Only intialize 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)
+    {
+        arch_spec.SetArchitecture (eArchTypeELF, header.e_machine, LLDB_INVALID_CPUTYPE);
+        arch_spec.GetTriple().setOSName (Host::GetOSString().GetCString());
+        arch_spec.GetTriple().setVendorName(Host::GetVendorString().GetCString());
+    }
+
     // We have already parsed the section headers
     if (!section_headers.empty())
         return section_headers.size();

     if (header.e_shnum == 0)
         return 0;
 
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
+
     section_headers.resize(header.e_shnum);
     if (section_headers.size() != header.e_shnum)
         return 0;

                     }
                 }
 
-                if (header.sh_type == SHT_NOTE && !uuid.IsValid())
+                // Process ELF note section entries.
+                if (header.sh_type == SHT_NOTE)
                 {
+                    // Allow notes to refine module info.
                     DataExtractor data;
                     if (section_size && (data.SetData (object_data, header.sh_offset, section_size) == section_size))
                     {
-                        ParseNoteGNUBuildID (data, uuid);
+                        Error error = RefineModuleDetailsFromNote (data, arch_spec, uuid);
+                        if (error.Fail ())
+                        {
+                            if (log)
+                                log->Printf ("ObjectFileELF::%s ELF note processing failed: %s", __FUNCTION__, error.AsCString ());
+                        }
                     }
                 }
             }

 size_t
 ObjectFileELF::ParseSectionHeaders()
 {
-    return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc);
+    return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
 }
 
 const ObjectFileELF::ELFSectionHeaderInfo *

     if (!ParseHeader())
         return false;
 
-    arch.SetArchitecture (eArchTypeELF, m_header.e_machine, LLDB_INVALID_CPUTYPE);
-    arch.GetTriple().setOSName (Host::GetOSString().GetCString());
-    arch.GetTriple().setVendorName(Host::GetVendorString().GetCString());
+    // Allow elf notes to be parsed which may affect the detected architecture.
+    ParseSectionHeaders();
+
+    arch = m_arch_spec;
     return true;
 }