Simplify ObjectFile::GetArchitecture

[labath]

Summary

instead of returning the architecture through by-ref argument and a
boolean value indicating success, we can just return the ArchSpec
directly. Since the ArchSpec already has an invalid state, it can be
used to denote the failure without the additional bool.

[JDevlieghere]

Maybe add a unit test for the operator bool? Otherwise this LGTM.

[labath]

Add unit test for ArchSpec::operator bool

include/lldb/Core/Module.h

static lldb::ModuleSP CreateModuleFromObjectFile(Args &&... args) {
     // so we need to control the creation carefully in this static function
     lldb::ModuleSP module_sp(new Module());
     module_sp->m_objfile_sp =
         std::make_shared<ObjFilePlugin>(module_sp, std::forward<Args>(args)...);
 
     // Once we get the object file, update our module with the object file's
     // architecture since it might differ in vendor/os if some parts were
     // unknown.
-    if (!module_sp->m_objfile_sp->GetArchitecture(module_sp->m_arch))
-      return nullptr;
-
+    if (ArchSpec arch = module_sp->m_objfile_sp->GetArchitecture()) {
+      module_sp->m_arch = arch;
       return module_sp;
     }
+    return nullptr;
+  }
 
   //------------------------------------------------------------------
   /// Destructor.
   //------------------------------------------------------------------
   ~Module() override;
 
   bool MatchesModuleSpec(const ModuleSpec &module_ref);
 

include/lldb/Expression/IRExecutionUnit.h

public:
   uint32_t GetAddressByteSize() const override;
 
   void PopulateSymtab(lldb_private::ObjectFile *obj_file,
                       lldb_private::Symtab &symtab) override;
 
   void PopulateSectionList(lldb_private::ObjectFile *obj_file,
                            lldb_private::SectionList &section_list) override;
 
-  bool GetArchitecture(lldb_private::ArchSpec &arch) override;
+  ArchSpec GetArchitecture() override;
 
   lldb::ModuleSP GetJITModule();
 
   lldb::addr_t FindSymbol(const ConstString &name);
 
   void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
 
   //----------------------------------------------------------------------

include/lldb/Symbol/ObjectFile.h

public:
   virtual uint32_t GetAddressByteSize() const = 0;
 
   virtual void PopulateSymtab(lldb_private::ObjectFile *obj_file,
                               lldb_private::Symtab &symtab) = 0;
 
   virtual void PopulateSectionList(lldb_private::ObjectFile *obj_file,
                                    lldb_private::SectionList &section_list) = 0;
 
-  virtual bool GetArchitecture(lldb_private::ArchSpec &arch) = 0;
+  virtual ArchSpec GetArchitecture() = 0;
 };
 
 //----------------------------------------------------------------------
 /// @class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h"
 /// A plug-in interface definition class for object file parsers.
 ///
 /// Object files belong to Module objects and know how to extract information
 /// from executable, shared library, and object (.o) files used by operating
public:
   ///
   /// @return
   ///     The const file specification object pointer if there is one,
   ///     or NULL if this object is only from memory.
   //------------------------------------------------------------------
   virtual const FileSpec &GetFileSpec() const { return m_file; }
 
   //------------------------------------------------------------------
-  /// Get the name of the cpu, vendor and OS for this object file.
-  ///
-  /// This value is a string that represents the target triple where the cpu
-  /// type, the vendor and the OS are encoded into a string.
-  ///
-  /// @param[out] target_triple
-  ///     The string value of the target triple.
+  /// Get the ArchSpec for this object file.
   ///
   /// @return
-  ///     \b True if the target triple was able to be computed, \b
-  ///     false otherwise.
+  ///     The ArchSpec of this object file. In case of error, an invalid
+  ///     ArchSpec object is returned.
   //------------------------------------------------------------------
-  virtual bool GetArchitecture(ArchSpec &arch) = 0;
+  virtual ArchSpec GetArchitecture() = 0;
 
   //------------------------------------------------------------------
   /// Gets the section list for the currently selected architecture (and
   /// object for archives).
   ///
   /// Section list parsing can be deferred by ObjectFile instances until this
   /// accessor is called the first time.
   ///

include/lldb/Symbol/UnwindTable.h

public:
   // don't add this new one to our UnwindTable. This FuncUnwinders object does
   // have a reference to the UnwindTable but the lifetime of this uncached
   // FuncUnwinders is expected to be short so in practice this will not be a
   // problem.
   lldb::FuncUnwindersSP
   GetUncachedFuncUnwindersContainingAddress(const Address &addr,
                                             SymbolContext &sc);
 
-  bool GetArchitecture(lldb_private::ArchSpec &arch);
+  ArchSpec GetArchitecture();
 
 private:
   void Dump(Stream &s);
 
   void Initialize();
   llvm::Optional<AddressRange> GetAddressRange(const Address &addr,
                                                SymbolContext &sc);
 

include/lldb/Utility/ArchSpec.h

public:
   /// Tests if this ArchSpec is valid.
   ///
   /// @return True if the current architecture is valid, false
   ///         otherwise.
   //------------------------------------------------------------------
   bool IsValid() const {
     return m_core >= eCore_arm_generic && m_core < kNumCores;
   }
+  explicit operator bool() const { return IsValid(); }
 
   bool TripleVendorWasSpecified() const {
     return !m_triple.getVendorName().empty();
   }
 
   bool TripleVendorIsUnspecifiedUnknown() const {
     return m_triple.getVendor() == llvm::Triple::UnknownVendor &&
            m_triple.getVendorName().empty();

source/Core/Module.cpp

if (process_sp) {
         if (m_objfile_sp) {
           StreamString s;
           s.Printf("0x%16.16" PRIx64, header_addr);
           m_object_name.SetString(s.GetString());
 
           // Once we get the object file, update our module with the object
           // file's architecture since it might differ in vendor/os if some
           // parts were unknown.
-          m_objfile_sp->GetArchitecture(m_arch);
+          m_arch = m_objfile_sp->GetArchitecture();
         } else {
           error.SetErrorString("unable to find suitable object file plug-in");
         }
       } else {
         error.SetErrorStringWithFormat("unable to read header from memory: %s",
                                        readmem_error.AsCString());
       }
     } else {
if (!m_did_load_objfile.load()) {
             shared_from_this(), &m_file, m_object_offset,
             file_size - m_object_offset, data_sp, data_offset);
         if (m_objfile_sp) {
           // Once we get the object file, update our module with the object
           // file's architecture since it might differ in vendor/os if some
           // parts were unknown.  But since the matching arch might already be
           // more specific than the generic COFF architecture, only merge in
           // those values that overwrite unspecified unknown values.
-          ArchSpec new_arch;
-          m_objfile_sp->GetArchitecture(new_arch);
-          m_arch.MergeFrom(new_arch);
+          m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
         } else {
           ReportError("failed to load objfile for %s",
                       GetFileSpec().GetPath().c_str());
         }
       }
     }
   }
   return m_objfile_sp.get();

source/Expression/IRExecutionUnit.cpp

if (record.m_size > 0) {
           record.m_size,         // file_size
           0,
           record.m_permissions)); // flags
       section_list.AddSection(section_sp);
     }
   }
 }
 
-bool IRExecutionUnit::GetArchitecture(lldb_private::ArchSpec &arch) {
+ArchSpec IRExecutionUnit::GetArchitecture() {
   ExecutionContext exe_ctx(GetBestExecutionContextScope());
-  Target *target = exe_ctx.GetTargetPtr();
-  if (target)
-    arch = target->GetArchitecture();
-  else
-    arch.Clear();
-  return arch.IsValid();
+  if(Target *target = exe_ctx.GetTargetPtr())
+    return target->GetArchitecture();
+  return ArchSpec();
 }
 
 lldb::ModuleSP IRExecutionUnit::GetJITModule() {
   ExecutionContext exe_ctx(GetBestExecutionContextScope());
   Target *target = exe_ctx.GetTargetPtr();
   if (!target)
     return nullptr;
 

source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.h

public:
   Symtab *GetSymtab() override;
 
   bool IsStripped() override { return false; }
 
   void CreateSections(SectionList &unified_section_list) override;
 
   void Dump(Stream *s) override {}
 
-  bool GetArchitecture(ArchSpec &arch) override;
+  ArchSpec GetArchitecture() override { return m_arch; }
 
   bool GetUUID(UUID *uuid) override;
 
   FileSpecList GetDebugSymbolFilePaths() override { return FileSpecList(); }
 
   uint32_t GetDependentModules(FileSpecList &files) override { return 0; }
 
   Type CalculateType() override { return eTypeDebugInfo; }

source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

bool ObjectFileBreakpad::ParseHeader() {
   return true;
 }
 
 Symtab *ObjectFileBreakpad::GetSymtab() {
   // TODO
   return nullptr;
 }
 
-bool ObjectFileBreakpad::GetArchitecture(ArchSpec &arch) {
-  arch = m_arch;
-  return true;
-}
-
 bool ObjectFileBreakpad::GetUUID(UUID *uuid) {
   *uuid = m_uuid;
   return true;
 }
 
 void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) {
   // TODO
 }

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

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

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (data_sp->GetByteSize() < length) {
     data_offset = 0;
     magic = data_sp->GetBytes();
   }
 
   unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
   if (address_size == 4 || address_size == 8) {
     std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(
         module_sp, data_sp, data_offset, file, file_offset, length));
-    ArchSpec spec;
-    if (objfile_ap->GetArchitecture(spec) &&
-        objfile_ap->SetModulesArchitecture(spec))
+    ArchSpec spec = objfile_ap->GetArchitecture();
+    if (spec && objfile_ap->SetModulesArchitecture(spec))
       return objfile_ap.release();
   }
 
   return NULL;
 }
 
 ObjectFile *ObjectFileELF::CreateMemoryInstance(
     const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
   if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
     const uint8_t *magic = data_sp->GetBytes();
     if (ELFHeader::MagicBytesMatch(magic)) {
       unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
       if (address_size == 4 || address_size == 8) {
         std::unique_ptr<ObjectFileELF> objfile_ap(
             new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
-        ArchSpec spec;
-        if (objfile_ap->GetArchitecture(spec) &&
-            objfile_ap->SetModulesArchitecture(spec))
+        ArchSpec spec = objfile_ap->GetArchitecture();
+        if (spec && objfile_ap->SetModulesArchitecture(spec))
           return objfile_ap.release();
       }
     }
   }
   return NULL;
 }
 
 bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
   // can't be restricted to Android because this special object file don't
   // contain the note section specifying the environment to Android but the
   // custom extension and file name makes it highly unlikely that this will
   // collide with anything else.
   ConstString file_extension = m_file.GetFileNameExtension();
   bool skip_oatdata_oatexec = file_extension == ConstString(".oat") ||
                               file_extension == ConstString(".odex");
 
-  ArchSpec arch;
-  GetArchitecture(arch);
+  ArchSpec arch = GetArchitecture();
   ModuleSP module_sp(GetModule());
   SectionList *module_section_list =
       module_sp ? module_sp->GetSectionList() : nullptr;
 
   // Local cache to avoid doing a FindSectionByName for each symbol. The "const
   // char*" key must came from a ConstString object so they can be compared by
   // pointer
   std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;
if (!module_sp) {
     return;
   }
 
   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
   s->Printf("%p: ", static_cast<void *>(this));
   s->Indent();
   s->PutCString("ObjectFileELF");
 
-  ArchSpec header_arch;
-  GetArchitecture(header_arch);
+  ArchSpec header_arch = GetArchitecture();
 
   *s << ", file = '" << m_file
      << "', arch = " << header_arch.GetArchitectureName() << "\n";
 
   DumpELFHeader(s, m_header);
   s->EOL();
   DumpELFProgramHeaders(s);
   s->EOL();
if (num_modules > 0) {
     s->PutCString("Dependent Modules:\n");
     for (unsigned i = 0; i < num_modules; ++i) {
       const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
       s->Printf("   %s\n", spec.GetFilename().GetCString());
     }
   }
 }
 
-bool ObjectFileELF::GetArchitecture(ArchSpec &arch) {
+ArchSpec ObjectFileELF::GetArchitecture() {
   if (!ParseHeader())
-    return false;
+    return ArchSpec();
 
   if (m_section_headers.empty()) {
     // Allow elf notes to be parsed which may affect the detected architecture.
     ParseSectionHeaders();
   }
 
   if (CalculateType() == eTypeCoreFile &&
       m_arch_spec.TripleOSIsUnspecifiedUnknown()) {
     // Core files don't have section headers yet they have PT_NOTE program
     // headers that might shed more light on the architecture
     for (const elf::ELFProgramHeader &H : ProgramHeaders()) {
       if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0)
         continue;
       DataExtractor data;
       if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) {
         UUID uuid;
         RefineModuleDetailsFromNote(data, m_arch_spec, uuid);
       }
     }
   }
-  arch = m_arch_spec;
-  return true;
+  return m_arch_spec;
 }
 
 ObjectFile::Type ObjectFileELF::CalculateType() {
   switch (m_header.e_type) {
   case llvm::ELF::ET_NONE:
     // 0 - No file type
     return eTypeUnknown;
 

source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
-  bool GetArchitecture(lldb_private::ArchSpec &arch) override;
+  lldb_private::ArchSpec GetArchitecture() override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   size_t ReadSectionData(lldb_private::Section *section,
                          lldb::offset_t section_offset, void *dst,
                          size_t dst_len) override;

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

 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();
     s->PutCString("ObjectFileJIT");
 
-    ArchSpec arch;
-    if (GetArchitecture(arch))
+    if (ArchSpec arch = GetArchitecture())
       *s << ", arch = " << arch.GetArchitectureName();
 
     s->EOL();
 
     SectionList *sections = GetSectionList();
     if (sections)
       sections->Dump(s, NULL, true, UINT32_MAX);
 

 }
 
 lldb_private::Address ObjectFileJIT::GetBaseAddress() { return Address(); }
 
 ObjectFile::Type ObjectFileJIT::CalculateType() { return eTypeJIT; }
 
 ObjectFile::Strata ObjectFileJIT::CalculateStrata() { return eStrataJIT; }
 
-bool ObjectFileJIT::GetArchitecture(ArchSpec &arch) {
-  ObjectFileJITDelegateSP delegate_sp(m_delegate_wp.lock());
-  if (delegate_sp)
-    return delegate_sp->GetArchitecture(arch);
-  return false;
+ArchSpec ObjectFileJIT::GetArchitecture() {
+  if (ObjectFileJITDelegateSP delegate_sp = m_delegate_wp.lock())
+    return delegate_sp->GetArchitecture();
+  return ArchSpec();
 }
 
 //------------------------------------------------------------------
 // PluginInterface protocol
 //------------------------------------------------------------------
 lldb_private::ConstString ObjectFileJIT::GetPluginName() {
   return GetPluginNameStatic();
 }

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

public:
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
-  bool GetArchitecture(lldb_private::ArchSpec &arch) override;
+  lldb_private::ArchSpec GetArchitecture() override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   lldb_private::FileSpecList GetReExportedLibraries() override {
     return m_reexported_dylibs;
   }

 
 protected:
   static bool
   GetUUID(const llvm::MachO::mach_header &header,
           const lldb_private::DataExtractor &data,
           lldb::offset_t lc_offset, // Offset to the first load command
           lldb_private::UUID &uuid);
 
-  static bool GetArchitecture(const llvm::MachO::mach_header &header,
-                              const lldb_private::DataExtractor &data,
-                              lldb::offset_t lc_offset,
-                              lldb_private::ArchSpec &arch);
+  static lldb_private::ArchSpec
+  GetArchitecture(const llvm::MachO::mach_header &header,
+                  lldb::offset_t lc_offset);
 
   // Intended for same-host arm device debugging where lldb needs to
   // detect libraries in the shared cache and augment the nlist entries
   // with an on-disk dyld_shared_cache file.  The process will record
   // the shared cache UUID so the on-disk cache can be matched or rejected
   // correctly.
   void GetProcessSharedCacheUUID(lldb_private::Process *, lldb::addr_t &base_addr, lldb_private::UUID &uuid);
 

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

if (ParseHeader(data, &data_offset, header)) {
         data_offset = MachHeaderSizeFromMagic(header.magic);
       }
       if (data_sp) {
         ModuleSpec spec;
         spec.GetFileSpec() = file;
         spec.SetObjectOffset(file_offset);
         spec.SetObjectSize(length);
 
-        if (GetArchitecture(header, data, data_offset,
-                            spec.GetArchitecture())) {
-          if (spec.GetArchitecture().IsValid()) {
-            GetUUID(header, data, data_offset, spec.GetUUID());
-            specs.Append(spec);
-          }
-        }
-      }
-    }
-  }
+        spec.GetArchitecture() = GetArchitecture(header, data, data_offset);
   return specs.GetSize() - initial_count;
 }
 
 const ConstString &ObjectFileMachO::GetSegmentNameTEXT() {
   static ConstString g_segment_name_TEXT("__TEXT");
   return g_segment_name_TEXT;
 }
 
if (module_sp) {
 
     default:
       break;
     }
 
     if (can_parse) {
       m_data.GetU32(&offset, &m_header.cputype, 6);
 
-      ArchSpec mach_arch;
-
-      if (GetArchitecture(mach_arch)) {
+      if (ArchSpec mach_arch = GetArchitecture()) {
         // Check if the module has a required architecture
         const ArchSpec &module_arch = module_sp->GetArchitecture();
         if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
           return false;
 
         if (SetModulesArchitecture(mach_arch)) {
           const size_t header_and_lc_size =
               m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();
     if (m_header.magic == MH_MAGIC_64 || m_header.magic == MH_CIGAM_64)
       s->PutCString("ObjectFileMachO64");
     else
       s->PutCString("ObjectFileMachO32");
 
-    ArchSpec header_arch;
-    GetArchitecture(header_arch);
+    ArchSpec header_arch = GetArchitecture();
 
     *s << ", file = '" << m_file
        << "', triple = " << header_arch.GetTriple().getTriple() << "\n";
 
     SectionList *sections = GetSectionList();
     if (sections)
       sections->Dump(s, NULL, true, UINT32_MAX);
 
struct MinOS {
     uint32_t major_version, minor_version, patch_version;
     MinOS(uint32_t version)
         : major_version(version >> 16),
           minor_version((version >> 8) & 0xffu),
           patch_version(version & 0xffu) {}
   };
 } // namespace
 
-bool ObjectFileMachO::GetArchitecture(const llvm::MachO::mach_header &header,
-                                      const lldb_private::DataExtractor &data,
-                                      lldb::offset_t lc_offset,
-                                      ArchSpec &arch) {
+ArchSpec
+ObjectFileMachO::GetArchitecture(const llvm::MachO::mach_header &header,
+                                 lldb::offset_t lc_offset) {
+  ArchSpec arch;
   arch.SetArchitecture(eArchTypeMachO, header.cputype, header.cpusubtype);
 
   if (arch.IsValid()) {
     llvm::Triple &triple = arch.GetTriple();
 
     // Set OS to an unspecified unknown or a "*" so it can match any OS
     triple.setOS(llvm::Triple::UnknownOS);
     triple.setOSName(llvm::StringRef());
 
     if (header.filetype == MH_PRELOAD) {
       if (header.cputype == CPU_TYPE_ARM) {
         // If this is a 32-bit arm binary, and it's a standalone binary, force
         // the Vendor to Apple so we don't accidentally pick up the generic
         // armv7 ABI at runtime.  Apple's armv7 ABI always uses r7 for the
         // frame pointer register; most other armv7 ABIs use a combination of
         // r7 and r11.
         triple.setVendor(llvm::Triple::Apple);
       } else {
         // Set vendor to an unspecified unknown or a "*" so it can match any
         // vendor This is required for correct behavior of EFI debugging on
         // x86_64
         triple.setVendor(llvm::Triple::UnknownVendor);
         triple.setVendorName(llvm::StringRef());
       }
-      return true;
+      return arch;
     } else {
       struct load_command load_cmd;
       llvm::SmallString<16> os_name;
       llvm::raw_svector_ostream os(os_name);
 
       // See if there is an LC_VERSION_MIN_* load command that can give
       // us the OS type.
       lldb::offset_t offset = lc_offset;
if (header.filetype == MH_PRELOAD) {
             break;
           if (data.ExtractBytes(cmd_offset, sizeof(version_min),
                                 data.GetByteOrder(), &version_min) == 0)
             break;
           MinOS min_os(version_min.version);
           os << GetOSName(load_cmd.cmd) << min_os.major_version << '.'
              << min_os.minor_version << '.' << min_os.patch_version;
           triple.setOSName(os.str());
-          return true;
+          return arch;
         }
         default:
           break;
         }
 
         offset = cmd_offset + load_cmd.cmdsize;
       }
 
if (header.filetype == MH_PRELOAD) {
             OSEnv os_env(build_version.platform);
             if (os_env.os_type.empty())
               break;
             os << os_env.os_type << min_os.major_version << '.'
                << min_os.minor_version << '.' << min_os.patch_version;
             triple.setOSName(os.str());
             if (!os_env.environment.empty())
               triple.setEnvironmentName(os_env.environment);
-            return true;
+            return arch;
           }
         } while (0);
         offset = cmd_offset + load_cmd.cmdsize;
       }
 
       if (header.filetype != MH_KEXT_BUNDLE) {
         // We didn't find a LC_VERSION_MIN load command and this isn't a KEXT
         // so lets not say our Vendor is Apple, leave it as an unspecified
         // unknown
         triple.setVendor(llvm::Triple::UnknownVendor);
         triple.setVendorName(llvm::StringRef());
       }
     }
   }
-  return arch.IsValid();
+  return arch;
 }
 
 bool ObjectFileMachO::GetUUID(lldb_private::UUID *uuid) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     return GetUUID(m_header, m_data, offset, *uuid);
if (version_cmd == LC_ID_DYLIB) {
       unsigned minor = (version & 0x0000FF00ull) >> 8;
       unsigned subminor = (version & 0x000000FFull);
       return llvm::VersionTuple(major, minor, subminor);
     }
   }
   return llvm::VersionTuple();
 }
 
-bool ObjectFileMachO::GetArchitecture(ArchSpec &arch) {
+ArchSpec ObjectFileMachO::GetArchitecture() {
   ModuleSP module_sp(GetModule());
+  ArchSpec arch;
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+
     return GetArchitecture(m_header, m_data,
-                           MachHeaderSizeFromMagic(m_header.magic), arch);
+                           MachHeaderSizeFromMagic(m_header.magic));
   }
-  return false;
+  return arch;
 }
 
 void ObjectFileMachO::GetProcessSharedCacheUUID(Process *process, addr_t &base_addr, UUID &uuid) {
   uuid.Clear();
   base_addr = LLDB_INVALID_ADDRESS;
   if (process && process->GetDynamicLoader()) {
     DynamicLoader *dl = process->GetDynamicLoader();
     LazyBool using_shared_cache;

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

public:
   lldb_private::Symtab *GetSymtab() override;
 
   bool IsStripped() override;
 
   void CreateSections(lldb_private::SectionList &unified_section_list) override;
 
   void Dump(lldb_private::Stream *s) override;
 
-  bool GetArchitecture(lldb_private::ArchSpec &arch) override;
+  lldb_private::ArchSpec GetArchitecture() override;
 
   bool GetUUID(lldb_private::UUID *uuid) override;
 
   uint32_t GetDependentModules(lldb_private::FileSpecList &files) override;
 
   virtual lldb_private::Address GetEntryPointAddress() override;
 
   ObjectFile::Type CalculateType() override;

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 void ObjectFilePECOFF::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();
     s->PutCString("ObjectFilePECOFF");
 
-    ArchSpec header_arch;
-    GetArchitecture(header_arch);
+    ArchSpec header_arch = GetArchitecture();
 
     *s << ", file = '" << m_file
        << "', arch = " << header_arch.GetArchitectureName() << "\n";
 
     SectionList *sections = GetSectionList();
     if (sections)
       sections->Dump(s, NULL, true, UINT32_MAX);
 
bool ObjectFilePECOFF::IsWindowsSubsystem() {
   case llvm::COFF::IMAGE_SUBSYSTEM_XBOX:
   case llvm::COFF::IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION:
     return true;
   default:
     return false;
   }
 }
 
-bool ObjectFilePECOFF::GetArchitecture(ArchSpec &arch) {
+ArchSpec ObjectFilePECOFF::GetArchitecture() {
   uint16_t machine = m_coff_header.machine;
   switch (machine) {
+  default:
+    break;
   case llvm::COFF::IMAGE_FILE_MACHINE_AMD64:
   case llvm::COFF::IMAGE_FILE_MACHINE_I386:
   case llvm::COFF::IMAGE_FILE_MACHINE_POWERPC:
   case llvm::COFF::IMAGE_FILE_MACHINE_POWERPCFP:
   case llvm::COFF::IMAGE_FILE_MACHINE_ARM:
   case llvm::COFF::IMAGE_FILE_MACHINE_ARMNT:
   case llvm::COFF::IMAGE_FILE_MACHINE_THUMB:
+    ArchSpec arch;
     arch.SetArchitecture(eArchTypeCOFF, machine, LLDB_INVALID_CPUTYPE,
                          IsWindowsSubsystem() ? llvm::Triple::Win32
                                               : llvm::Triple::UnknownOS);
-    return true;
-  default:
-    break;
+    return arch;
   }
-  return false;
+  return ArchSpec();
 }
 
 ObjectFile::Type ObjectFilePECOFF::CalculateType() {
   if (m_coff_header.machine != 0) {
     if ((m_coff_header.flags & llvm::COFF::IMAGE_FILE_DLL) == 0)
       return eTypeExecutable;
     else
       return eTypeSharedLibrary;

source/Plugins/Process/elf-core/ProcessElfCore.cpp

 
 uint32_t ProcessElfCore::GetNumThreadContexts() {
   if (!m_thread_data_valid)
     DoLoadCore();
   return m_thread_data.size();
 }
 
 ArchSpec ProcessElfCore::GetArchitecture() {
-  ArchSpec arch;
-  m_core_module_sp->GetObjectFile()->GetArchitecture(arch);
+  ArchSpec arch = m_core_module_sp->GetObjectFile()->GetArchitecture();
 
   ArchSpec target_arch = GetTarget().GetArchitecture();
   arch.MergeFrom(target_arch);
 
   // On MIPS there is no way to differentiate betwenn 32bit and 64bit core
   // files and this information can't be merged in from the target arch so we
   // fail back to unconditionally returning the target arch in this config.
   if (target_arch.IsMIPS()) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (dwarf_cu_die) {
           /*
            * MIPS:
            * The SymbolContext may not have a valid target, thus we may not be
            * able
            * to call Address::GetOpcodeLoadAddress() which would clear the bit
            * #0
            * for MIPS. Use ArchSpec to clear the bit #0.
           */
-          ArchSpec arch;
-          GetObjectFile()->GetArchitecture(arch);
-          switch (arch.GetMachine()) {
+          switch (GetObjectFile()->GetArchitecture().GetMachine()) {
           case llvm::Triple::mips:
           case llvm::Triple::mipsel:
           case llvm::Triple::mips64:
           case llvm::Triple::mips64el:
             info.addr_mask = ~((lldb::addr_t)1);
             break;
           default:
             info.addr_mask = ~((lldb::addr_t)0);

source/Symbol/CompactUnwindInfo.cpp

if (!IsValid(target.GetProcessSP())) {
     return false;
   }
   FunctionInfo function_info;
   if (GetCompactUnwindInfoForFunction(target, addr, function_info)) {
     // shortcut return for functions that have no compact unwind
     if (function_info.encoding == 0)
       return false;
 
-    ArchSpec arch;
-    if (m_objfile.GetArchitecture(arch)) {
+    if (ArchSpec arch = m_objfile.GetArchitecture()) {
 
       Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
       if (log && log->GetVerbose()) {
         StreamString strm;
         addr.Dump(
             &strm, NULL,
             Address::DumpStyle::DumpStyleResolvedDescriptionNoFunctionArguments,
             Address::DumpStyle::DumpStyleFileAddress,
if (m_unwindinfo_data.GetByteSize() > 0) {
 
     // struct unwind_info_section_header_index_entry {
     //     uint32_t        functionOffset;
     //     uint32_t        secondLevelPagesSectionOffset;
     //     uint32_t        lsdaIndexArraySectionOffset;
     // };
 
     bool clear_address_zeroth_bit = false;
-    ArchSpec arch;
-    if (m_objfile.GetArchitecture(arch)) {
+    if (ArchSpec arch = m_objfile.GetArchitecture()) {
       if (arch.GetTriple().getArch() == llvm::Triple::arm ||
           arch.GetTriple().getArch() == llvm::Triple::thumb)
         clear_address_zeroth_bit = true;
     }
 
     offset = indexSectionOffset;
     for (uint32_t idx = 0; idx < indexCount; idx++) {
       uint32_t function_offset =

source/Symbol/DWARFCallFrameInfo.cpp

void DWARFCallFrameInfo::GetFDEIndex() {
   if (m_fde_index_initialized) // if two threads hit the locker
     return;
 
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "%s - %s", LLVM_PRETTY_FUNCTION,
                      m_objfile.GetFileSpec().GetFilename().AsCString(""));
 
   bool clear_address_zeroth_bit = false;
-  ArchSpec arch;
-  if (m_objfile.GetArchitecture(arch)) {
+  if (ArchSpec arch = m_objfile.GetArchitecture()) {
     if (arch.GetTriple().getArch() == llvm::Triple::arm ||
         arch.GetTriple().getArch() == llvm::Triple::thumb)
       clear_address_zeroth_bit = true;
   }
 
   lldb::offset_t offset = 0;
   if (!m_cfi_data_initialized)
     GetCFIData();

source/Symbol/FuncUnwinders.cpp

 
 const Address &FuncUnwinders::GetFunctionStartAddress() const {
   return m_range.GetBaseAddress();
 }
 
 lldb::UnwindAssemblySP
 FuncUnwinders::GetUnwindAssemblyProfiler(Target &target) {
   UnwindAssemblySP assembly_profiler_sp;
-  ArchSpec arch;
-  if (m_unwind_table.GetArchitecture(arch)) {
+  if (ArchSpec arch = m_unwind_table.GetArchitecture()) {
     arch.MergeFrom(target.GetArchitecture());
     assembly_profiler_sp = UnwindAssembly::FindPlugin(arch);
   }
   return assembly_profiler_sp;
 }
 
 Address FuncUnwinders::GetLSDAAddress(Target &target) {
   Address lsda_addr;

source/Symbol/Type.cpp

case eEncodingIsTypedefUID: {
       if (m_byte_size == 0)
         m_byte_size = GetLayoutCompilerType().GetByteSize(nullptr);
     } break;
 
     // If we are a pointer or reference, then this is just a pointer size;
     case eEncodingIsPointerUID:
     case eEncodingIsLValueReferenceUID:
     case eEncodingIsRValueReferenceUID: {
-      ArchSpec arch;
-      if (m_symbol_file->GetObjectFile()->GetArchitecture(arch))
+      if (ArchSpec arch = m_symbol_file->GetObjectFile()->GetArchitecture())
         m_byte_size = arch.GetAddressByteSize();
     } break;
     }
   }
   return m_byte_size;
 }
 
 uint32_t Type::GetNumChildren(bool omit_empty_base_classes) {

source/Symbol/UnwindTable.cpp

CompactUnwindInfo *UnwindTable::GetCompactUnwindInfo() {
   return m_compact_unwind_up.get();
 }
 
 ArmUnwindInfo *UnwindTable::GetArmUnwindInfo() {
   Initialize();
   return m_arm_unwind_up.get();
 }
 
-bool UnwindTable::GetArchitecture(lldb_private::ArchSpec &arch) {
-  return m_object_file.GetArchitecture(arch);
+ArchSpec UnwindTable::GetArchitecture() {
+  return m_object_file.GetArchitecture();
 }
 
 bool UnwindTable::GetAllowAssemblyEmulationUnwindPlans() {
   return m_object_file.AllowAssemblyEmulationUnwindPlans();
 }

unittests/Utility/ArchSpecTest.cpp

TEST(ArchSpecTest, Compatibility) {
   {
     ArchSpec A("x86_64");
     ArchSpec B("x86_64-apple-macosx10.14");
     // FIXME: The exact match also looks unintuitive.
     ASSERT_TRUE(A.IsExactMatch(B));
     ASSERT_TRUE(A.IsCompatibleMatch(B));
   }
 }
+
+TEST(ArchSpecTest, OperatorBool) {
+  EXPECT_FALSE(ArchSpec());
+  EXPECT_TRUE(ArchSpec("x86_64-pc-linux"));
+}