No Issue - Fixes for building with LLVM 19 included with FreeBSD 13.5.

Fix a conflict with libc++ 19 and the old Mozilla (re)alloc macros.
LLVM 18+ does not allow std::char_traits<unsigned char> so avoid it.
https://bugzilla.mozilla.org/show_bug.cgi?id=1849070
Partial NSS upgrade to replace ByteString with a class.
https://bugzilla.mozilla.org/show_bug.cgi?id=1851092

gfx/graphite2/src/MozGrMalloc.h

@@ -12,8 +12,22 @@
 
 #include "mozilla/mozalloc.h"
 
-#define malloc(a) moz_xmalloc(a)
-#define calloc(a, b) moz_xcalloc(a, b)
-#define realloc(a, b) moz_xrealloc(a, b)
+// extern "C" is needed for the Solaris build, while the inline
+// functions are needed for the MinGW build.
+
+extern "C" inline void* malloc(size_t size)
+{
+    return moz_xmalloc(size);
+}
+
+extern "C" inline void* calloc(size_t nmemb, size_t size)
+{
+    return moz_xcalloc(nmemb, size);
+}
+
+extern "C" inline void* realloc(void *ptr, size_t size)
+{
+    return moz_xrealloc(ptr, size);
+}
 
 #endif // MOZ_GR_MALLOC_H

js/src/builtin/intl/Locale.cpp

@@ -746,8 +746,9 @@ static inline auto FindUnicodeExtensionType(JSLinearString* unicodeExtension,
                                             UnicodeKey key) {
   JS::AutoCheckCannotGC nogc;
   return unicodeExtension->hasLatin1Chars()
-             ? FindUnicodeExtensionType(unicodeExtension->latin1Chars(nogc),
-                                        unicodeExtension->length(), key)
+             ? FindUnicodeExtensionType(
+                   reinterpret_cast<const char*>(unicodeExtension->latin1Chars(nogc)),
+                   unicodeExtension->length(), key)
              : FindUnicodeExtensionType(unicodeExtension->twoByteChars(nogc),
                                         unicodeExtension->length(), key);
 }
@@ -858,7 +859,9 @@ static BaseNamePartsResult BaseNameParts(const CharT* baseName, size_t length) {
 static inline auto BaseNameParts(JSLinearString* baseName) {
   JS::AutoCheckCannotGC nogc;
   return baseName->hasLatin1Chars()
-             ? BaseNameParts(baseName->latin1Chars(nogc), baseName->length())
+             ? BaseNameParts(
+                   reinterpret_cast<const char*>(baseName->latin1Chars(nogc)),
+                   baseName->length())
              : BaseNameParts(baseName->twoByteChars(nogc), baseName->length());
 }
 

security/nss/lib/mozpkix/include/pkix-test/pkixtestutil.h

@@ -36,7 +36,31 @@ namespace mozilla {
 namespace pkix {
 namespace test {
 
-typedef std::basic_string<uint8_t> ByteString;
+class ByteString : public std::string {
+ public:
+  ByteString() {}
+  ByteString(size_t count, uint8_t value) : std::string(count, char(value)) {}
+  explicit ByteString(const uint8_t* data)
+      : std::string(reinterpret_cast<const char*>(data)) {}
+  ByteString(const uint8_t* data, size_t length)
+      : std::string(reinterpret_cast<const char*>(data), length) {}
+  ByteString operator+(const ByteString& rhs) const {
+    ByteString result = *this;
+    result.std::string::append(rhs);
+    return result;
+  }
+  const uint8_t* data() const {
+    return reinterpret_cast<const uint8_t*>(std::string::data());
+  }
+  void assign(const uint8_t* data, size_t length) {
+    std::string::assign(reinterpret_cast<const char*>(data), length);
+  }
+  void append(const ByteString& other) { std::string::append(other); }
+  void append(const uint8_t* data, size_t length) {
+    std::string::append(reinterpret_cast<const char*>(data), length);
+  }
+  void push_back(uint8_t c) { std::string::push_back(char(c)); }
+};
 
 inline bool ENCODING_FAILED(const ByteString& bs) { return bs.empty(); }