Add UUID::SetFromOptionalStringRef, use it in DynamicLoaderDarwin

[jingham]

Summary

When you build a macOS binary with -no_uuid, we get a binary blob of all 0's from the file, and we read that in with UUID::fromOptionalData, so we get an invalid UUID. When debugserver tells us about the binaries that have been loaded, it returns a UUID string of all 0's. We need these two to match. If we use SetFromStringRef in the latter case, we end up with a valid UUID of all 0's, so they don't match.

This patch adds SetFromOptionalStringRef to mirror the from...Bytes API's, and use it in the macOS Dynamic loader.

I added tests in UUIDTests.cpp to ensure this behavior.

[labath]

lgtm

include/lldb/Utility/UUID.h

public:
   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;
 
   size_t SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes = 16);
   
+  // Same as SetFromStringRef, but if the resultant UUID is all 0 bytes, set the 
+  // UUID to invalid.
+  size_t SetFromOptionalStringRef(llvm::StringRef str, 
+                                  uint32_t num_uuid_bytes = 16);
+
   // Decode as many UUID bytes (up to 16) as possible from the C string "cstr"
   // This is used for auto completion where a partial UUID might have been
   // typed in. It
   //------------------------------------------------------------------
   /// Decode as many UUID bytes (up to 16) as possible from the C
   /// string \a cstr.
   ///
   /// @param[in] cstr

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.SetFromStringRef(
+    image_infos[i].uuid.SetFromOptionalStringRef(
         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.
 

source/Utility/UUID.cpp

size_t UUID::SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes) {
   if (bytes.size() == num_uuid_bytes) {
     *this = fromData(bytes);
     return str.size() - rest.size();
   }
 
   // Else return zero to indicate we were not able to parse a UUID value
   return 0;
 }
+
+size_t UUID::SetFromOptionalStringRef(llvm::StringRef str, 
+                                      uint32_t num_uuid_bytes) {
+  size_t num_chars_consumed = SetFromStringRef(str, num_uuid_bytes);
+  if (num_chars_consumed) {
+    if (llvm::all_of(m_bytes, [](uint8_t b) { return b == 0; }))
+        Clear();
+  }
+  
+  return num_chars_consumed;
+}
+

unittests/Utility/UUIDTest.cpp

 
 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 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);
 }
 
 TEST(UUIDTest, SetFromStringRef) {
   UUID u;
   EXPECT_EQ(32u, u.SetFromStringRef("404142434445464748494a4b4c4d4e4f"));
   EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), u);
 
   EXPECT_EQ(36u, u.SetFromStringRef("40-41-42-43-4445464748494a4b4c4d4e4f"));