1 //===-- UUID.h --------------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_UTILITY_UUID_H 10 #define LLDB_UTILITY_UUID_H 11 12 #include "llvm/ADT/ArrayRef.h" 13 #include "llvm/ADT/StringRef.h" 14 #include "llvm/Support/Endian.h" 15 #include <cstddef> 16 #include <cstdint> 17 #include <string> 18 19 namespace lldb_private { 20 21 class Stream; 22 23 class UUID { 24 public: 25 UUID() = default; 26 27 // Reference: 28 // https://crashpad.chromium.org/doxygen/structcrashpad_1_1CodeViewRecordPDB70.html 29 struct CvRecordPdb70 { 30 struct { 31 llvm::support::ulittle32_t Data1; 32 llvm::support::ulittle16_t Data2; 33 llvm::support::ulittle16_t Data3; 34 uint8_t Data4[8]; 35 } Uuid; 36 llvm::support::ulittle32_t Age; 37 // char PDBFileName[]; 38 }; 39 40 /// Create a UUID from CvRecordPdb70. 41 static UUID fromCvRecord(CvRecordPdb70 debug_info); 42 43 /// Creates a UUID from the data pointed to by the bytes argument. No special 44 /// significance is attached to any of the values. 45 static UUID fromData(const void *bytes, uint32_t num_bytes) { 46 if (bytes) 47 return fromData({reinterpret_cast<const uint8_t *>(bytes), num_bytes}); 48 return UUID(); 49 } 50 51 /// Creates a uuid from the data pointed to by the bytes argument. No special 52 /// significance is attached to any of the values. 53 static UUID fromData(llvm::ArrayRef<uint8_t> bytes) { return UUID(bytes); } 54 55 /// Creates a UUID from the data pointed to by the bytes argument. Data 56 /// consisting purely of zero bytes is treated as an invalid UUID. 57 static UUID fromOptionalData(const void *bytes, uint32_t num_bytes) { 58 if (bytes) 59 return fromOptionalData( 60 {reinterpret_cast<const uint8_t *>(bytes), num_bytes}); 61 return UUID(); 62 } 63 64 /// Creates a UUID from the data pointed to by the bytes argument. Data 65 /// consisting purely of zero bytes is treated as an invalid UUID. 66 static UUID fromOptionalData(llvm::ArrayRef<uint8_t> bytes) { 67 if (llvm::all_of(bytes, [](uint8_t b) { return b == 0; })) 68 return UUID(); 69 return UUID(bytes); 70 } 71 72 void Clear() { m_bytes.clear(); } 73 74 void Dump(Stream *s) const; 75 76 llvm::ArrayRef<uint8_t> GetBytes() const { return m_bytes; } 77 78 explicit operator bool() const { return IsValid(); } 79 bool IsValid() const { return !m_bytes.empty(); } 80 81 std::string GetAsString(llvm::StringRef separator = "-") const; 82 83 bool SetFromStringRef(llvm::StringRef str); 84 85 // Same as SetFromStringRef, but if the resultant UUID is all 0 bytes, set the 86 // UUID to invalid. 87 bool SetFromOptionalStringRef(llvm::StringRef str); 88 89 /// Decode as many UUID bytes as possible from the C string \a cstr. 90 /// 91 /// \param[in] str 92 /// An llvm::StringRef that points at a UUID string value (no leading 93 /// spaces). The string must contain only hex characters and optionally 94 /// can contain the '-' sepearators. 95 /// 96 /// \param[in] uuid_bytes 97 /// A buffer of bytes that will contain a full or partially decoded UUID. 98 /// 99 /// \return 100 /// The original string, with all decoded bytes removed. 101 static llvm::StringRef 102 DecodeUUIDBytesFromString(llvm::StringRef str, 103 llvm::SmallVectorImpl<uint8_t> &uuid_bytes); 104 105 private: 106 UUID(llvm::ArrayRef<uint8_t> bytes) : m_bytes(bytes.begin(), bytes.end()) {} 107 108 // GNU ld generates 20-byte build-ids. Size chosen to avoid heap allocations 109 // for this case. 110 llvm::SmallVector<uint8_t, 20> m_bytes; 111 112 friend bool operator==(const UUID &LHS, const UUID &RHS) { 113 return LHS.m_bytes == RHS.m_bytes; 114 } 115 friend bool operator!=(const UUID &LHS, const UUID &RHS) { 116 return !(LHS == RHS); 117 } 118 friend bool operator<(const UUID &LHS, const UUID &RHS) { 119 return LHS.m_bytes < RHS.m_bytes; 120 } 121 friend bool operator<=(const UUID &LHS, const UUID &RHS) { 122 return !(RHS < LHS); 123 } 124 friend bool operator>(const UUID &LHS, const UUID &RHS) { return RHS < LHS; } 125 friend bool operator>=(const UUID &LHS, const UUID &RHS) { 126 return !(LHS < RHS); 127 } 128 }; 129 } // namespace lldb_private 130 131 #endif // LLDB_UTILITY_UUID_H 132