Treat a UUID of all zeros consistently to mean "Invalid UUID"

[jingham]

Summary

At present, there are two ways to get data into a UUID object, an unchecked version and what's called the "Optional" version. So for instance, there's setFromData and setFromOptionalData. The difference is that the Optional version looks at the UUID bytes and if they are all 0's it clears the data store for the UUID, rendering it an Invalid UUID.

However, there was no apparatus for determining which of these two variants to use. The PDB version always uses the Optional version, the Darwin support code used both somewhat inconsistently. The ELF object file code uses the unchecked version. And the generic parts of the code sometimes use one and sometimes another. So the current approach is not very coherent.

On Darwin, treating all-zero's UUID's as significant is actually wrong behavior - so that needs to be changed. But that still leaves the system seeming arbitrary. For instance, SBModuleSpec::SetUUIDBytes uses the checked method. So even if some ObjectFile format treats UUID's of 0 as significant, you wouldn't be able to find it with SBModuleSpec.

My guess is this is all just historical and it would be fine to treat UUID's of 0 as meaning "not valid for matching", which is what this patch does.

If this is not the case, we'll have to add something like ObjectFile::AllZerosUUIDIsValid, and then check it everywhere outside the object file reader that we build UUID's. But I'd rather not do that if there isn't a compelling reason to do so.

[clayborg]

Minidump files have UUID values that are zeroed out. We will need to do something for these that can sense all zeroes and return a default constructed one.

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

72

Minidump files created by Google's Breakpad generates UUIDs with zeros:

Modules[2].CvRecord.location.DataSize = 0x00000032 (50)
Modules[2].CvRecord.location.Rva = 0x000698e0
Modules[2].CvRecord.signature    = 0x53445352 (Pdb70)
Modules[2].CvRecord.uuid         = 00000000-0000-0000-0000-000000000000
Modules[2].CvRecord.age          = 0x00000000
Modules[2].CvRecord.pdb_name     = system@[e-mail]

It would be fine to just check for the "pdb70_uuid->Uuid" being all zeroes here and return a default constructed UUID object

[clayborg]

lldb/source/API/SBModuleSpec.cpp

137

If we want this API to be consistent to what it was doing before, then we need to check for all zeroes here too?

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

1392

Have you checked if the kernel ever just specifies all zeroes here? It it does, this will change things right?

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

888

More LC_UUID values are valid AFAIK, so this should be ok.

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

70–73

Fix the UUID UUID::fromCvRecord(UUID::CvRecordPdb70) function and call that function from here.

lldb/source/Utility/UUID.cpp

45

Ditto above comment from the MinidumpParser. Actually this function should be used, the implementation from the MinidumpParser should use this function.

[jingham]

In D132191#3734014, @clayborg wrote:

Minidump files have UUID values that are zeroed out. We will need to do something for these that can sense all zeroes and return a default constructed one.

I'm confused. The MinidumParser.cpp already used fromOptionalData and fromOptionalStringRef to create its UUID's. So this patch won't change the Minidump behavior.

[jingham]

Remember, all this patch does is make a universal rule that "All zero UUID's are placeholders and not meant to be matched against." The only platforms/ObjectFile readers that weren't already following that rule were Darwin - where this was definitely just historical accident - and ObjectFileELF. Then there were a few places in generic code where we seem to have tossed a coin for which behavior to use. Windows & Breakpad were already calling the "Optional" version of the set functions. So this is only a change in behavior for ELF.

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

1392

On Darwin, UUID's of all zeros always means "I had to put in a UUID, but I don't actually want you to use it". I don't know whether the Kernel currently produces this or not - it's currently used for the stub binaries that Playgrounds uses.

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

70–73

Note that fromCvRecord already used the fromOptional version, so its behavior doesn't change with this patch. I don't think anything else needs to be done here.

[labath]

lldb/include/lldb/Utility/UUID.h

50–51

The main reason this was a factory function was so that we could use the factory name to disambiguate between the two interpretations of zero "uuids".

As we're removing that, we could also go back to using regular constructors for object creation.

[jingham]

Remove the static factories and replace them with constructors.

This was mostly mechanical, but a biggish patch against the previous version, so I thought I'd put this up for one more look in case folks were interested.

lldb/include/lldb/Utility/UUID.h

 #include <cstdint>
 #include <string>
 
 namespace lldb_private {
 
   class Stream;
 
 class UUID {
+  // Represents UUID's of various sizes.  In all cases, a uuid of all zeros is
+  // treated as an "Invalid UUID" marker, and the UUID created from such data
+  // will return false for IsValid.
 public:
   UUID() = default;
   
+  /// Creates a uuid from the data pointed to by the bytes argument.
+  UUID(llvm::ArrayRef<uint8_t> bytes) : m_bytes(bytes.begin(), bytes.end()) {
+    if (llvm::all_of(m_bytes, [](uint8_t b) { return b == 0; })) {
+      Clear();
+   }
+  }
+
   // Reference:
   // https://crashpad.chromium.org/doxygen/structcrashpad_1_1CodeViewRecordPDB70.html
   struct CvRecordPdb70 {
     struct {
       llvm::support::ulittle32_t Data1;
       llvm::support::ulittle16_t Data2;
       llvm::support::ulittle16_t Data3;
       uint8_t Data4[8];
     } Uuid;
     llvm::support::ulittle32_t Age;
     // char PDBFileName[];
   };
 
   /// Create a UUID from CvRecordPdb70.
-  static UUID fromCvRecord(CvRecordPdb70 debug_info);
+  UUID(CvRecordPdb70 debug_info);
 
-  /// Creates a UUID from the data pointed to by the bytes argument. No special
-  /// significance is attached to any of the values.
-  static UUID fromData(const void *bytes, uint32_t num_bytes) {
-    if (bytes)
-      return fromData({reinterpret_cast<const uint8_t *>(bytes), num_bytes});
-    return UUID();
-  }
-
-  /// Creates a uuid from the data pointed to by the bytes argument. No special
-  /// significance is attached to any of the values.
-  static UUID fromData(llvm::ArrayRef<uint8_t> bytes) { return UUID(bytes); }
-
-  /// Creates a UUID from the data pointed to by the bytes argument. Data
-  /// consisting purely of zero bytes is treated as an invalid UUID.
-  static UUID fromOptionalData(const void *bytes, uint32_t num_bytes) {
-    if (bytes)
-      return fromOptionalData(
-          {reinterpret_cast<const uint8_t *>(bytes), num_bytes});
-    return UUID();
-  }
-
-  /// Creates a UUID from the data pointed to by the bytes argument. Data
-  /// consisting purely of zero bytes is treated as an invalid UUID.
-  static UUID fromOptionalData(llvm::ArrayRef<uint8_t> bytes) {
-    if (llvm::all_of(bytes, [](uint8_t b) { return b == 0; }))
-      return UUID();
-    return UUID(bytes);
+  /// Creates a UUID from the data pointed to by the bytes argument. 
+  UUID(const void *bytes, uint32_t num_bytes) {
+    if (!bytes)
+      return;
+    *this 
+        = UUID(llvm::ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(bytes), 
+               num_bytes));
   }
 
   void Clear() { m_bytes.clear(); }
 
   void Dump(Stream *s) const;
 
   llvm::ArrayRef<uint8_t> GetBytes() const { return m_bytes; }
 
   explicit operator bool() const { return IsValid(); }
   bool IsValid() const { return !m_bytes.empty(); }
   
   std::string GetAsString(llvm::StringRef separator = "-") const;
 
   bool SetFromStringRef(llvm::StringRef str);
 
-  // Same as SetFromStringRef, but if the resultant UUID is all 0 bytes, set the
-  // UUID to invalid.
-  bool SetFromOptionalStringRef(llvm::StringRef str);
-
   /// Decode as many UUID bytes as possible from the C string \a cstr.
   ///
   /// \param[in] str
   ///     An llvm::StringRef that points at a UUID string value (no leading
   ///     spaces). The string must contain only hex characters and optionally
   ///     can contain the '-' sepearators.
   ///
   /// \param[in] uuid_bytes
   ///     A buffer of bytes that will contain a full or partially decoded UUID.
   ///
   /// \return
   ///     The original string, with all decoded bytes removed.
   static llvm::StringRef
   DecodeUUIDBytesFromString(llvm::StringRef str,
                             llvm::SmallVectorImpl<uint8_t> &uuid_bytes);
 
 private:
-  UUID(llvm::ArrayRef<uint8_t> bytes) : m_bytes(bytes.begin(), bytes.end()) {}
-
   // GNU ld generates 20-byte build-ids. Size chosen to avoid heap allocations
   // for this case.
   llvm::SmallVector<uint8_t, 20> m_bytes;
 
   friend bool operator==(const UUID &LHS, const UUID &RHS) {
     return LHS.m_bytes == RHS.m_bytes;
   }
   friend bool operator!=(const UUID &LHS, const UUID &RHS) {

lldb/source/API/SBModuleSpec.cpp

 size_t SBModuleSpec::GetUUIDLength() {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetUUID().GetBytes().size();
 }
 
 bool SBModuleSpec::SetUUIDBytes(const uint8_t *uuid, size_t uuid_len) {
   LLDB_INSTRUMENT_VA(this, uuid, uuid_len)
-  m_opaque_up->GetUUID() = UUID::fromOptionalData(uuid, uuid_len);
+  m_opaque_up->GetUUID() = UUID(uuid, uuid_len);
   return m_opaque_up->GetUUID().IsValid();
 }
 
 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
   LLDB_INSTRUMENT_VA(this, description);
 
   m_opaque_up->Dump(description.ref());
   return true;

lldb/source/Core/DataFileCache.cpp

bool CacheSignature::Decode(const lldb_private::DataExtractor &data,
                             lldb::offset_t *offset_ptr) {
   Clear();
   while (uint8_t sig_encoding = data.GetU8(offset_ptr)) {
     switch (sig_encoding) {
     case eSignatureUUID: {
       const uint8_t length = data.GetU8(offset_ptr);
       const uint8_t *bytes = (const uint8_t *)data.GetData(offset_ptr, length);
       if (bytes != nullptr && length > 0)
-        m_uuid = UUID::fromData(llvm::ArrayRef<uint8_t>(bytes, length));
+        m_uuid = UUID(llvm::ArrayRef<uint8_t>(bytes, length));
     } break;
     case eSignatureModTime: {
       uint32_t mod_time = data.GetU32(offset_ptr);
       if (mod_time > 0)
         m_mod_time = mod_time;
     } break;
     case eSignatureObjectModTime: {
       uint32_t mod_time = data.GetU32(offset_ptr);

lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm

if (dyld_process_create_for_current_task) {
                                                   uint64_t vmSize, int perm) {
           minVmAddr = std::min(minVmAddr, vmAddr);
           maxVmAddr = std::max(maxVmAddr, vmAddr + vmSize);
           dyld_image_copy_uuid(image, uuid);
         });
         assert(minVmAddr != UINT_MAX);
         assert(maxVmAddr != 0);
         m_images[dyld_image_get_installname(image)] = SharedCacheImageInfo{
-            UUID::fromData(uuid, 16),
+            UUID(uuid, 16),
             std::make_shared<DataBufferUnowned>((uint8_t *)minVmAddr,
                                                 maxVmAddr - minVmAddr)};
       });
       return true;
     }
   }
 #endif
   return false;
 }
 
 SharedCacheInfo::SharedCacheInfo() {
   if (CreateSharedCacheInfoWithInstrospectionSPIs())
     return;
 
   size_t shared_cache_size;
   uint8_t *shared_cache_start =
       _dyld_get_shared_cache_range(&shared_cache_size);
   uuid_t dsc_uuid;
   _dyld_get_shared_cache_uuid(dsc_uuid);
-  m_uuid = UUID::fromData(dsc_uuid);
+  m_uuid = UUID(dsc_uuid);
 
   dyld_shared_cache_iterate_text(
       dsc_uuid, ^(const dyld_shared_cache_dylib_text_info *info) {
         m_images[info->path] = SharedCacheImageInfo{
-            UUID::fromData(info->dylibUuid, 16),
+            UUID(info->dylibUuid, 16),
             std::make_shared<DataBufferUnowned>(
                 shared_cache_start + info->textSegmentOffset,
                 shared_cache_size - info->textSegmentOffset)};
       });
 }
 
 SharedCacheImageInfo
 HostInfoMacOSX::GetSharedCacheImageInfo(llvm::StringRef image_name) {
   static SharedCacheInfo g_shared_cache_info;
   return g_shared_cache_info.GetImages().lookup(image_name);
 }

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

for (uint32_t kext_summary_offset = 0;
                                             m_kext_summary_header.entry_size);
          ++i, kext_summary_offset += m_kext_summary_header.entry_size) {
       lldb::offset_t offset = kext_summary_offset;
       const void *name_data =
           extractor.GetData(&offset, KERNEL_MODULE_MAX_NAME);
       if (name_data == nullptr)
         break;
       image_infos[i].SetName((const char *)name_data);
-      UUID uuid = UUID::fromOptionalData(extractor.GetData(&offset, 16), 16);
+      UUID uuid(extractor.GetData(&offset, 16), 16);
       image_infos[i].SetUUID(uuid);
       image_infos[i].SetLoadAddress(extractor.GetU64(&offset));
       image_infos[i].SetSize(extractor.GetU64(&offset));
     }
     if (i < image_infos.size())
       image_infos.resize(i);
   } else {
     image_infos.clear();

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

for (size_t j = 0; j < segcount; j++) {
         segment.nsects =
             seg->GetValueForKey("nsects")->GetAsInteger()->GetValue();
       else
         segment.nsects = 0;
 
       image_infos[i].segments.push_back(segment);
     }
 
-    image_infos[i].uuid.SetFromOptionalStringRef(
+    image_infos[i].uuid.SetFromStringRef(
         image->GetValueForKey("uuid")->GetAsString()->GetValue());
 
     // All sections listed in the dyld image info structure will all either be
     // fixed up already, or they will all be off by a single slide amount that
     // is determined by finding the first segment that is at file offset zero
     // which also has bytes (a file size that is greater than zero) in the
     // object file.
 

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

if (data.ValidOffsetForDataOfSize(offset,
               load_cmd_offset + data.GetU32(&offset);
           const char *path = data.PeekCStr(name_offset);
           lc_id_dylinker->SetFile(path, FileSpec::Style::native);
           FileSystem::Instance().Resolve(*lc_id_dylinker);
         }
         break;
 
       case llvm::MachO::LC_UUID:
-        dylib_info.uuid = UUID::fromOptionalData(data.GetData(&offset, 16), 16);
+        dylib_info.uuid = UUID(data.GetData(&offset, 16), 16);
         break;
 
       default:
         break;
       }
       // Set offset to be the beginning of the next load command.
       offset = load_cmd_offset + load_cmd.cmdsize;
     }
if (version_or_magic != static_cast<uint32_t>(-1) &&
       if (wordsize == 4) {
         sharedCacheUUID_address =
             all_image_infos + 84; // sharedCacheUUID <mach-o/dyld_images.h>
       }
       if (sharedCacheUUID_address != LLDB_INVALID_ADDRESS) {
         uuid_t shared_cache_uuid;
         if (m_process->ReadMemory(sharedCacheUUID_address, shared_cache_uuid,
                                   sizeof(uuid_t), err) == sizeof(uuid_t)) {
-          uuid = UUID::fromOptionalData(shared_cache_uuid, 16);
+          uuid = UUID(shared_cache_uuid, 16);
           if (uuid.IsValid()) {
             using_shared_cache = eLazyBoolYes;
           }
         }
 
         if (version_or_magic >= 15) {
           // The sharedCacheBaseAddress field is the next one in the
           // dyld_all_image_infos struct.

lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp

static UUID parseModuleId(llvm::Triple::OSType os, llvm::StringRef str) {
   uint32_t age;
   bool success = to_integer(age_str, age, 16);
   assert(success);
   (void)success;
   data.age = age;
 
   // On non-windows, the age field should always be zero, so we don't include to
   // match the native uuid format of these platforms.
-  return UUID::fromData(&data, os == llvm::Triple::Win32 ? sizeof(data)
-                                                         : sizeof(data.uuid));
+  return UUID(&data, os == llvm::Triple::Win32 ? sizeof(data)
 }
 
 llvm::Optional<Record::Kind> Record::classify(llvm::StringRef Line) {
   Token Tok = consume<Token>(Line);
   switch (Tok) {
   case Token::Module:
     return Record::Module;
   case Token::Info:

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (header.Parse(data, &header_offset)) {
               } else {
                 gnu_debuglink_crc = calc_crc32(0, data);
               }
             }
             using u32le = llvm::support::ulittle32_t;
             if (gnu_debuglink_crc) {
               // Use 4 bytes of crc from the .gnu_debuglink section.
               u32le data(gnu_debuglink_crc);
-              uuid = UUID::fromData(&data, sizeof(data));
+              uuid = UUID(&data, sizeof(data));
             } else if (core_notes_crc) {
               // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
               // it look different form .gnu_debuglink crc followed by 4 bytes
               // of note segments crc.
               u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
-              uuid = UUID::fromData(data, sizeof(data));
+              uuid = UUID(data, sizeof(data));
             }
           }
 
           specs.Append(spec);
         }
       }
     }
   }
if (GetType() == ObjectFile::eTypeCoreFile) {
       core_notes_crc =
           CalculateELFNotesSegmentsCRC32(m_program_headers, m_data);
 
       if (core_notes_crc) {
         // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
         // look different form .gnu_debuglink crc - followed by 4 bytes of note
         // segments crc.
         u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
-        m_uuid = UUID::fromData(data, sizeof(data));
+        m_uuid = UUID(data, sizeof(data));
       }
     } else {
       if (!m_gnu_debuglink_crc)
         m_gnu_debuglink_crc = calc_crc32(0, m_data);
       if (m_gnu_debuglink_crc) {
         // Use 4 bytes of crc from the .gnu_debuglink section.
         u32le data(m_gnu_debuglink_crc);
-        m_uuid = UUID::fromData(&data, sizeof(data));
+        m_uuid = UUID(&data, sizeof(data));
       }
     }
   }
 
   return m_uuid;
 }
 
 llvm::Optional<FileSpec> ObjectFileELF::GetDebugLink() {
else if (note.n_name == LLDB_NT_OWNER_GNU) {
         // Only bother processing this if we don't already have the uuid set.
         if (!uuid.IsValid()) {
           // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
           // build-id of a different length. Accept it as long as it's at least
           // 4 bytes as it will be better than our own crc32.
           if (note.n_descsz >= 4) {
             if (const uint8_t *buf = data.PeekData(offset, note.n_descsz)) {
               // Save the build id as the UUID for the module.
-              uuid = UUID::fromData(buf, note.n_descsz);
+              uuid = UUID(buf, note.n_descsz);
             } else {
               error.SetErrorString("failed to read GNU_BUILD_ID note payload");
               return error;
             }
           }
         }
         break;
       }

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

UUID ObjectFileMachO::GetSharedCacheUUID(FileSpec dyld_shared_cache,
   DataExtractor dsc_header_data(DscData, byte_order, addr_byte_size);
 
   char version_str[7];
   lldb::offset_t offset = 0;
   memcpy(version_str, dsc_header_data.GetData(&offset, 6), 6);
   version_str[6] = '\0';
   if (strcmp(version_str, "dyld_v") == 0) {
     offset = offsetof(struct lldb_copy_dyld_cache_header_v1, uuid);
-    dsc_uuid = UUID::fromOptionalData(
-        dsc_header_data.GetData(&offset, sizeof(uuid_t)), sizeof(uuid_t));
+    dsc_uuid = UUID(dsc_header_data.GetData(&offset, sizeof(uuid_t)), 
+                    sizeof(uuid_t));
   }
   Log *log = GetLog(LLDBLog::Symbols);
   if (log && dsc_uuid.IsValid()) {
     LLDB_LOGF(log, "Shared cache %s has UUID %s",
               dyld_shared_cache.GetPath().c_str(),
               dsc_uuid.GetAsString().c_str());
   }
   return dsc_uuid;
case LC_FUNCTION_STARTS:
         memset(&function_starts_load_command, 0,
                sizeof(function_starts_load_command));
       break;
 
     case LC_UUID: {
       const uint8_t *uuid_bytes = m_data.PeekData(offset, 16);
 
       if (uuid_bytes)
-        image_uuid = UUID::fromOptionalData(uuid_bytes, 16);
+        image_uuid = UUID(uuid_bytes, 16);
       break;
     }
 
     default:
       break;
     }
     offset = cmd_offset + lc.cmdsize;
   }
if (IsSharedCacheBinary()) {
 
     dyld_for_each_installed_shared_cache(^(dyld_shared_cache_t shared_cache) {
       uuid_t cache_uuid;
       dyld_shared_cache_copy_uuid(shared_cache, &cache_uuid);
       if (found_image)
         return;
 
         if (process_shared_cache_uuid.IsValid() &&
-          process_shared_cache_uuid != UUID::fromOptionalData(&cache_uuid, 16))
+          process_shared_cache_uuid != UUID::fromData(&cache_uuid, 16))
         return;
 
       dyld_shared_cache_for_each_image(shared_cache, ^(dyld_image_t image) {
         uuid_t dsc_image_uuid;
         if (found_image)
           return;
 
         dyld_image_copy_uuid(image, &dsc_image_uuid);
-        if (image_uuid != UUID::fromOptionalData(dsc_image_uuid, 16))
+        if (image_uuid != UUID::fromData(dsc_image_uuid, 16))
           return;
 
         found_image = true;
 
         // Compute the size of the string table. We need to ask dyld for a
         // new SPI to avoid this step.
         dyld_image_local_nlist_content_4Symbolication(
             image, ^(const void *nlistStart, uint64_t nlistCount,
if (load_cmd.cmd == LC_UUID) {
 
         const uint8_t opencl_uuid[] = {0x8c, 0x8e, 0xb3, 0x9b, 0x3b, 0xa8,
                                        0x4b, 0x16, 0xb6, 0xa4, 0x27, 0x63,
                                        0xbb, 0x14, 0xf0, 0x0d};
 
         if (!memcmp(uuid_bytes, opencl_uuid, 16))
           return UUID();
 
-        return UUID::fromOptionalData(uuid_bytes, 16);
+        return UUID(uuid_bytes, 16);
       }
       return UUID();
     }
     offset = cmd_offset + load_cmd.cmdsize;
   }
   return UUID();
 }
 
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
               return false;
             if (value == LLDB_INVALID_ADDRESS &&
                 slide != LLDB_INVALID_ADDRESS) {
               value = slide;
               value_is_offset = true;
             }
 
             if (m_data.CopyData(offset, sizeof(uuid_t), raw_uuid) != 0) {
-              if (!uuid_is_null(raw_uuid))
-                uuid = UUID::fromOptionalData(raw_uuid, sizeof(uuid_t));
+              uuid = UUID(raw_uuid, sizeof(uuid_t));
               // convert the "main bin spec" type into our
               // ObjectFile::BinaryType enum
               switch (binspec_type) {
               case 0:
                 type = eBinaryTypeUnknown;
                 break;
               case 1:
                 type = eBinaryTypeKernel;
if (dyld_all_image_infos_address) {
           if (*version >= 15) {
             base_addr = 0;
             base_addr =
                 *(uint32_t
                       *)((uint8_t *)dyld_all_image_infos_address +
                          100); // sharedCacheBaseAddress <mach-o/dyld_images.h>
           }
         }
-        uuid = UUID::fromOptionalData(sharedCacheUUID_address, sizeof(uuid_t));
+        uuid = UUID(sharedCacheUUID_address, sizeof(uuid_t));
       }
     }
   } else {
     // Exists in macOS 10.12 and later, iOS 10.0 and later - dyld SPI
     dyld_process_info (*dyld_process_info_create)(
         unsigned int /* task_t */ task, uint64_t timestamp,
         unsigned int /*kern_return_t*/ *kernelError);
     void (*dyld_process_info_get_cache)(void *info, void *cacheInfo);
if (dyld_process_info_create && dyld_process_info_get_cache) {
       dyld_process_info process_info =
           dyld_process_info_create(::mach_task_self(), 0, &kern_ret);
       if (process_info) {
         struct lldb_copy__dyld_process_cache_info sc_info;
         memset(&sc_info, 0, sizeof(struct lldb_copy__dyld_process_cache_info));
         dyld_process_info_get_cache(process_info, &sc_info);
         if (sc_info.cacheBaseAddress != 0) {
           base_addr = sc_info.cacheBaseAddress;
-          uuid = UUID::fromOptionalData(sc_info.cacheUUID, sizeof(uuid_t));
+          uuid = UUID(sc_info.cacheUUID, sizeof(uuid_t));
         }
         dyld_process_info_release(process_info);
       }
     }
   }
   Log *log(GetLog(LLDBLog::Symbols | LLDBLog::Process));
   if (log && uuid.IsValid())
     LLDB_LOGF(log,
if (lc.cmd == LC_NOTE) {
                  sizeof(uuid_t));
           uint64_t load_address = m_data.GetU64(&offset);
           offset_t seg_addrs_offset = m_data.GetU64(&offset);
           uint32_t segment_count = m_data.GetU32(&offset);
           uint32_t currently_executing = m_data.GetU32(&offset);
 
           MachOCorefileImageEntry image_entry;
           image_entry.filename = (const char *)m_data.GetCStr(&filepath_offset);
-          if (!uuid_is_null(uuid))
-            image_entry.uuid = UUID::fromData(uuid, sizeof(uuid_t));
+          image_entry.uuid = UUID(uuid, sizeof(uuid_t));
           image_entry.load_address = load_address;
           image_entry.currently_executing = currently_executing;
 
           offset_t seg_vmaddrs_offset = seg_addrs_offset;
           for (uint32_t j = 0; j < segment_count; j++) {
             char segname[17];
             m_data.CopyData(seg_vmaddrs_offset, 16, segname);
             segname[16] = '\0';
if (lc.cmd == LC_NOTE) {
           memcpy(&uuid, m_data.GetData(&fileoff, sizeof(uuid_t)),
                  sizeof(uuid_t));
           uint64_t load_address = m_data.GetU64(&fileoff);
           uint64_t slide = m_data.GetU64(&fileoff);
           std::string filename = m_data.GetCStr(&fileoff);
 
           MachOCorefileImageEntry image_entry;
           image_entry.filename = filename;
-          if (!uuid_is_null(uuid))
-            image_entry.uuid = UUID::fromData(uuid, sizeof(uuid_t));
+          image_entry.uuid = UUID(uuid, sizeof(uuid_t));
           image_entry.load_address = load_address;
           image_entry.slide = slide;
           image_entry.currently_executing = true;
           image_infos.all_image_infos.push_back(image_entry);
         }
       }
     }
     offset = cmd_offset + lc.cmdsize;

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

 using namespace llvm::codeview;
 
 LLDB_PLUGIN_DEFINE(ObjectFilePDB)
 
 static UUID GetPDBUUID(InfoStream &IS) {
   UUID::CvRecordPdb70 debug_info;
   memcpy(&debug_info.Uuid, IS.getGuid().Guid, sizeof(debug_info.Uuid));
   debug_info.Age = IS.getAge();
-  return UUID::fromCvRecord(debug_info);
+  return UUID(debug_info);
 }
 
 char ObjectFilePDB::ID;
 
 void ObjectFilePDB::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 CreateMemoryInstance, GetModuleSpecifications);

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

static UUID GetCoffUUID(llvm::object::COFFObjectFile &coff_obj) {
 
   // First, prefer to use the PDB build id. LLD generates this even for mingw
   // targets without PDB output, and it does not get stripped either.
   if (!coff_obj.getDebugPDBInfo(pdb_info, pdb_file) && pdb_info) {
     if (pdb_info->PDB70.CVSignature == llvm::OMF::Signature::PDB70) {
       UUID::CvRecordPdb70 info;
       memcpy(&info.Uuid, pdb_info->PDB70.Signature, sizeof(info.Uuid));
       info.Age = pdb_info->PDB70.Age;
-      return UUID::fromCvRecord(info);
+      return UUID(info);
     }
   }
 
   std::string gnu_debuglink_file;
   uint32_t gnu_debuglink_crc;
 
   // The GNU linker normally does not write a PDB build id (unless requested
   // with the --build-id option), so we should fall back to using the crc
   // from .gnu_debuglink if it exists, just like how ObjectFileELF does it.
   if (!GetDebugLinkContents(coff_obj, gnu_debuglink_file, gnu_debuglink_crc)) {
     // If there is no .gnu_debuglink section, then this may be an object
     // containing DWARF debug info for .gnu_debuglink, so calculate the crc of
     // the object itself.
     auto raw_data = coff_obj.getData();
     LLDB_SCOPED_TIMERF(
         "Calculating module crc32 %s with size %" PRIu64 " KiB",
         FileSpec(coff_obj.getFileName()).GetLastPathComponent().AsCString(),
         static_cast<lldb::offset_t>(raw_data.size()) / 1024);
     gnu_debuglink_crc = llvm::crc32(0, llvm::arrayRefFromStringRef(raw_data));
   }
   // Use 4 bytes of crc from the .gnu_debuglink section.
   llvm::support::ulittle32_t data(gnu_debuglink_crc);
-  return UUID::fromData(&data, sizeof(data));
+  return UUID(&data, sizeof(data));
 }
 
 char ObjectFilePECOFF::ID;
 
 void ObjectFilePECOFF::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 CreateMemoryInstance, GetModuleSpecifications,

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

const CvSignature cv_signature =
       static_cast<CvSignature>(static_cast<uint32_t>(*signature));
 
   if (cv_signature == CvSignature::Pdb70) {
     const UUID::CvRecordPdb70 *pdb70_uuid = nullptr;
     Status error = consumeObject(cv_record, pdb70_uuid);
     if (error.Fail())
       return UUID();
     if (GetArchitecture().GetTriple().isOSBinFormatELF()) {
       if (pdb70_uuid->Age != 0)
-        return UUID::fromOptionalData(pdb70_uuid, sizeof(*pdb70_uuid));
-      return UUID::fromOptionalData(&pdb70_uuid->Uuid,
+        return UUID(pdb70_uuid, sizeof(*pdb70_uuid));
+      return UUID(&pdb70_uuid->Uuid,
                                     sizeof(pdb70_uuid->Uuid));
     }
-    return UUID::fromCvRecord(*pdb70_uuid);
+    return UUID(*pdb70_uuid);
   } else if (cv_signature == CvSignature::ElfBuildId)
-    return UUID::fromOptionalData(cv_record);
+    return UUID(cv_record);
 
   return UUID();
 }
 
 llvm::ArrayRef<minidump::Thread> MinidumpParser::GetThreads() {
   auto ExpectedThreads = GetMinidumpFile().getThreadList();
   if (ExpectedThreads)
     return *ExpectedThreads;

lldb/source/Utility/UUID.cpp

static inline bool separate(size_t count) {
   case 6:
   case 8:
     return true;
   default:
     return false;
   }
 }
 
-UUID UUID::fromCvRecord(UUID::CvRecordPdb70 debug_info) {
+UUID::UUID(UUID::CvRecordPdb70 debug_info) {
   llvm::sys::swapByteOrder(debug_info.Uuid.Data1);
   llvm::sys::swapByteOrder(debug_info.Uuid.Data2);
   llvm::sys::swapByteOrder(debug_info.Uuid.Data3);
   llvm::sys::swapByteOrder(debug_info.Age);
   if (debug_info.Age)
-    return UUID::fromOptionalData(&debug_info, sizeof(debug_info));
-  return UUID::fromOptionalData(&debug_info.Uuid, sizeof(debug_info.Uuid));
+    *this = UUID(&debug_info, sizeof(debug_info));
+  else
+    *this = UUID(&debug_info.Uuid, sizeof(debug_info.Uuid));
 }
 
 std::string UUID::GetAsString(llvm::StringRef separator) const {
   std::string result;
   llvm::raw_string_ostream os(result);
 
   for (auto B : llvm::enumerate(GetBytes())) {
     if (separate(B.index()))
bool UUID::SetFromStringRef(llvm::StringRef str) {
   llvm::SmallVector<uint8_t, 20> bytes;
   llvm::StringRef rest = UUID::DecodeUUIDBytesFromString(p, bytes);
 
   // Return false if we could not consume the entire string or if the parsed
   // UUID is empty.
   if (!rest.empty() || bytes.empty())
     return false;
 
-  *this = fromData(bytes);
+  *this = UUID(bytes);
   return true;
 }
-
-bool UUID::SetFromOptionalStringRef(llvm::StringRef str) {
-  bool result = SetFromStringRef(str);
-  if (result) {
-    if (llvm::all_of(m_bytes, [](uint8_t b) { return b == 0; }))
-        Clear();
-  }
-
-  return result;
-}

lldb/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp

TEST(Record, classify) {
   // Any line which does not start with a known keyword will be classified as a
   // line record, as those are the only ones that start without a keyword.
   EXPECT_EQ(Record::Line, Record::classify("deadbeef"));
   EXPECT_EQ(Record::Line, Record::classify("12"));
 }
 
 TEST(ModuleRecord, parse) {
   EXPECT_EQ(ModuleRecord(llvm::Triple::Linux, llvm::Triple::x86_64,
-                         UUID::fromData("@ABCDEFGHIJKLMNO", 16)),
+                         UUID("@ABCDEFGHIJKLMNO", 16)),
             ModuleRecord::parse(
                 "MODULE Linux x86_64 404142434445464748494a4b4c4d4e4f0 a.out"));
 
   EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE"));
   EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE Linux"));
   EXPECT_EQ(llvm::None, ModuleRecord::parse("MODULE Linux x86_64"));
   EXPECT_EQ(llvm::None,
             ModuleRecord::parse("MODULE Linux x86_64 deadbeefbaadf00d"));
 }
 
 TEST(InfoRecord, parse) {
-  EXPECT_EQ(InfoRecord(UUID::fromData("@ABCDEFGHIJKLMNO", 16)),
+  EXPECT_EQ(InfoRecord(UUID("@ABCDEFGHIJKLMNO", 16)),
             InfoRecord::parse("INFO CODE_ID 404142434445464748494a4b4c4d4e4f"));
   EXPECT_EQ(InfoRecord(UUID()), InfoRecord::parse("INFO CODE_ID 47 a.exe"));
 
   EXPECT_EQ(llvm::None, InfoRecord::parse("INFO"));
   EXPECT_EQ(llvm::None, InfoRecord::parse("INFO CODE_ID"));
 }
 
 TEST(FileRecord, parse) {

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

HandlePacket(
       R"([{"uuid":"404142434445464748494a4b4c4d4e4f","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])");
 
   auto result = async_result.get();
   ASSERT_TRUE(result.has_value());
   ASSERT_EQ(1u, result->size());
   EXPECT_EQ("/foo/bar.so", result.value()[0].GetFileSpec().GetPath());
   EXPECT_EQ(triple, result.value()[0].GetArchitecture().GetTriple());
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16),
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16),
             result.value()[0].GetUUID());
   EXPECT_EQ(0u, result.value()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.value()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo_UUID20) {
   llvm::Triple triple("i386-pc-linux");
 
   FileSpec file_spec("/foo/bar.so", FileSpec::Style::posix);
   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
       std::async(std::launch::async,
                  [&] { return client.GetModulesInfo(file_spec, triple); });
   HandlePacket(
       server,
       "jModulesInfo:["
       R"({"file":"/foo/bar.so","triple":"i386-pc-linux"}])",
       R"([{"uuid":"404142434445464748494a4b4c4d4e4f50515253","triple":"i386-pc-linux",)"
       R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])");
 
   auto result = async_result.get();
   ASSERT_TRUE(result.has_value());
   ASSERT_EQ(1u, result->size());
   EXPECT_EQ("/foo/bar.so", result.value()[0].GetFileSpec().GetPath());
   EXPECT_EQ(triple, result.value()[0].GetArchitecture().GetTriple());
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20),
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNOPQRS", 20),
             result.value()[0].GetUUID());
   EXPECT_EQ(0u, result.value()[0].GetObjectOffset());
   EXPECT_EQ(1234u, result.value()[0].GetObjectSize());
 }
 
 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfoInvalidResponse) {
   llvm::Triple triple("i386-pc-linux");
   FileSpec file_spec("/foo/bar.so", FileSpec::Style::posix);

lldb/unittests/SymbolFile/DWARF/DWARFIndexCachingTest.cpp

TEST(DWARFIndexCachingTest, CacheSignatureTests) {
   EncodeDecode(sig, /*encode_result=*/false);
   sig.Clear();
 
   sig.m_obj_mod_time = 0x12345678;
   EXPECT_FALSE(sig.IsValid());
   EncodeDecode(sig, /*encode_result=*/false);
   sig.Clear();
 
-  sig.m_uuid = UUID::fromData("@\x00\x11\x22\x33\x44\x55\x66\x77", 8);
+  sig.m_uuid = UUID("@\x00\x11\x22\x33\x44\x55\x66\x77", 8);
   EXPECT_TRUE(sig.IsValid());
   EncodeDecode(sig, /*encode_result=*/true);
   sig.m_mod_time = 0x12345678;
   EXPECT_TRUE(sig.IsValid());
   EncodeDecode(sig, /*encode_result=*/true);
   sig.m_obj_mod_time = 0x456789ab;
   EXPECT_TRUE(sig.IsValid());
   EncodeDecode(sig, /*encode_result=*/true);

lldb/unittests/Utility/UUIDTest.cpp

 //===-- UUIDTest.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Utility/UUID.h"
 
 using namespace lldb_private;
 
 TEST(UUIDTest, RelationalOperators) {
   UUID empty;
-  UUID a16 = UUID::fromData("1234567890123456", 16);
-  UUID b16 = UUID::fromData("1234567890123457", 16);
-  UUID a20 = UUID::fromData("12345678901234567890", 20);
-  UUID b20 = UUID::fromData("12345678900987654321", 20);
+  UUID a16 = UUID("1234567890123456", 16);
+  UUID b16 = UUID("1234567890123457", 16);
+  UUID a20 = UUID("12345678901234567890", 20);
+  UUID b20 = UUID("12345678900987654321", 20);
 
   EXPECT_EQ(empty, empty);
   EXPECT_EQ(a16, a16);
   EXPECT_EQ(a20, a20);
 
   EXPECT_NE(a16, b16);
   EXPECT_NE(a20, b20);
   EXPECT_NE(a16, a20);
   EXPECT_NE(empty, a16);
 
   EXPECT_LT(empty, a16);
   EXPECT_LT(a16, a20);
   EXPECT_LT(a16, b16);
   EXPECT_GT(a20, b20);
 }
 
 TEST(UUIDTest, Validity) {
   UUID empty;
   std::vector<uint8_t> zeroes(20, 0);
-  UUID a16 = UUID::fromData(zeroes.data(), 16);
-  UUID a20 = UUID::fromData(zeroes.data(), 20);
-  UUID a16_0 = UUID::fromOptionalData(zeroes.data(), 16);
-  UUID a20_0 = UUID::fromOptionalData(zeroes.data(), 20);
+  UUID a16 = UUID(zeroes.data(), 16);
+  UUID a20 = UUID(zeroes.data(), 20);
   UUID from_str;
   from_str.SetFromStringRef("00000000-0000-0000-0000-000000000000");
-  UUID opt_from_str;
-  opt_from_str.SetFromOptionalStringRef("00000000-0000-0000-0000-000000000000");
 
   EXPECT_FALSE(empty);
-  EXPECT_TRUE(a16);
-  EXPECT_TRUE(a20);
-  EXPECT_TRUE(from_str);
-  EXPECT_FALSE(a16_0);
-  EXPECT_FALSE(a20_0);
-  EXPECT_FALSE(opt_from_str);
+  EXPECT_FALSE(a16);
+  EXPECT_FALSE(a20);
+  EXPECT_FALSE(from_str);
 }
 
 TEST(UUIDTest, SetFromStringRef) {
   UUID u;
   EXPECT_TRUE(u.SetFromStringRef("404142434445464748494a4b4c4d4e4f"));
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16), u);
 
   EXPECT_TRUE(u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f"));
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16), u);
 
   EXPECT_TRUE(
       u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f-50515253"));
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u);
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNOPQRS", 20), u);
 
   EXPECT_TRUE(u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f"));
 
   EXPECT_FALSE(u.SetFromStringRef("40xxxxx"));
   EXPECT_FALSE(u.SetFromStringRef(""));
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u)
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16), u)
       << "uuid was changed by failed parse calls";
 
   EXPECT_TRUE(u.SetFromStringRef("404142434445464748494a4b4c4d4e4f-50515253"));
-  EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), u);
+  EXPECT_EQ(UUID("@ABCDEFGHIJKLMNOPQRS", 20), u);
 
   EXPECT_TRUE(u.SetFromStringRef("40414243"));
-  EXPECT_EQ(UUID::fromData("@ABCD", 4), u);
+  EXPECT_EQ(UUID("@ABCD", 4), u);
 
   EXPECT_FALSE(u.SetFromStringRef("4"));
 }
 
 TEST(UUIDTest, StringConverion) {
-  EXPECT_EQ("40414243", UUID::fromData("@ABC", 4).GetAsString());
-  EXPECT_EQ("40414243-4445-4647", UUID::fromData("@ABCDEFG", 8).GetAsString());
+  EXPECT_EQ("40414243", UUID("@ABC", 4).GetAsString());
+  EXPECT_EQ("40414243-4445-4647", UUID("@ABCDEFG", 8).GetAsString());
   EXPECT_EQ("40414243-4445-4647-4849-4A4B",
-            UUID::fromData("@ABCDEFGHIJK", 12).GetAsString());
+            UUID("@ABCDEFGHIJK", 12).GetAsString());
   EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F",
-            UUID::fromData("@ABCDEFGHIJKLMNO", 16).GetAsString());
+            UUID("@ABCDEFGHIJKLMNO", 16).GetAsString());
   EXPECT_EQ("40414243-4445-4647-4849-4A4B4C4D4E4F-50515253",
-            UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20).GetAsString());
+            UUID("@ABCDEFGHIJKLMNOPQRS", 20).GetAsString());
 }