Move UTF functions into namespace llvm.

[jlebar]

Summary

This lets people link against LLVM and their own version of the UTF
library.

I determined this only affects llvm, clang, lld, and lldb by running

$ git grep -wl 'UTF[0-9]\+\|\bConvertUTF\bisLegalUTF\|getNumBytesFor' | cut -f 1 -d '/' | sort | uniq

clang
lld
lldb
llvm

Tested with

ninja lldb
ninja check-clang check-llvm check-lld

(ninja check-lldb doesn't complete for me with or without this patch.)

[StefanVK]

This broke the build on windows/msvc (see http://lab.llvm.org:8011/builders/clang-x86-windows-msvc2015/builds/766)

Host/windows/Windows.cpp
Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp
Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

use:
llvm::UTF16;
llvm::UTF8;
llvm::UTF32;
llvm::ConversionFlags;
llvm::conversionOK;
llvm::strictConversion;

But have no using declaration or other means of finding the moved typedefs

Edit: I wrote a possible patch https://reviews.llvm.org/D25089 (just added a few llvm::)

[jlebar]

Sorry for the breakage. Interestingly I never got buildbot email about that one; I don't know if that's a bug.

clang/lib/Analysis/FormatString.cpp

clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
   return true;
 }
 
 bool clang::analyze_format_string::ParseUTF8InvalidSpecifier(
     const char *SpecifierBegin, const char *FmtStrEnd, unsigned &Len) {
   if (SpecifierBegin + 1 >= FmtStrEnd)
     return false;
 
-  const UTF8 *SB = reinterpret_cast<const UTF8 *>(SpecifierBegin + 1);
-  const UTF8 *SE = reinterpret_cast<const UTF8 *>(FmtStrEnd);
+  const llvm::UTF8 *SB =
+      reinterpret_cast<const llvm::UTF8 *>(SpecifierBegin + 1);
+  const llvm::UTF8 *SE = reinterpret_cast<const llvm::UTF8 *>(FmtStrEnd);
   const char FirstByte = *SB;
 
   // If the invalid specifier is a multibyte UTF-8 string, return the
   // total length accordingly so that the conversion specifier can be
   // properly updated to reflect a complete UTF-8 specifier.
-  unsigned NumBytes = getNumBytesForUTF8(FirstByte);
+  unsigned NumBytes = llvm::getNumBytesForUTF8(FirstByte);
   if (NumBytes == 1)
     return false;
   if (SB + NumBytes > SE)
     return false;
 
   Len = NumBytes + 1;
   return true;
 }

clang/lib/CodeGen/CodeGenModule.cpp

GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
   if (!Literal->containsNonAsciiOrNull()) {
     StringLength = NumBytes;
     return *Map.insert(std::make_pair(String, nullptr)).first;
   }
 
   // Otherwise, convert the UTF8 literals into a string of shorts.
   IsUTF16 = true;
 
-  SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
-  const UTF8 *FromPtr = (const UTF8 *)String.data();
-  UTF16 *ToPtr = &ToBuf[0];
-
-  (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
-                           &ToPtr, ToPtr + NumBytes,
-                           strictConversion);
+  SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
+  const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
+  llvm::UTF16 *ToPtr = &ToBuf[0];
+
+  (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
+                                 ToPtr + NumBytes, llvm::strictConversion);
 
   // ConvertUTF8toUTF16 returns the length in ToPtr.
   StringLength = ToPtr - &ToBuf[0];
 
   // Add an explicit null.
   *ToPtr = 0;
   return *Map.insert(std::make_pair(
                          StringRef(reinterpret_cast<const char *>(ToBuf.data()),

clang/lib/Format/Encoding.h

 enum Encoding {
   Encoding_UTF8,
   Encoding_Unknown // We treat all other encodings as 8-bit encodings.
 };
 
 /// \brief Detects encoding of the Text. If the Text can be decoded using UTF-8,
 /// it is considered UTF8, otherwise we treat it as some 8-bit encoding.
 inline Encoding detectEncoding(StringRef Text) {
-  const UTF8 *Ptr = reinterpret_cast<const UTF8 *>(Text.begin());
-  const UTF8 *BufEnd = reinterpret_cast<const UTF8 *>(Text.end());
-  if (::isLegalUTF8String(&Ptr, BufEnd))
+  const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin());
+  const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end());
+  if (llvm::isLegalUTF8String(&Ptr, BufEnd))
     return Encoding_UTF8;
   return Encoding_Unknown;
 }
 
 inline unsigned getCodePointCountUTF8(StringRef Text) {
   unsigned CodePoints = 0;
-  for (size_t i = 0, e = Text.size(); i < e; i += getNumBytesForUTF8(Text[i])) {
+  for (size_t i = 0, e = Text.size(); i < e;
+       i += llvm::getNumBytesForUTF8(Text[i])) {
     ++CodePoints;
   }
   return CodePoints;
 }
 
 /// \brief Gets the number of code points in the Text using the specified
 /// Encoding.
 inline unsigned getCodePointCount(StringRef Text, Encoding Encoding) {
inline unsigned columnWidthWithTabs(StringRef Text, unsigned StartColumn,
   }
 }
 
 /// \brief Gets the number of bytes in a sequence representing a single
 /// codepoint and starting with FirstChar in the specified Encoding.
 inline unsigned getCodePointNumBytes(char FirstChar, Encoding Encoding) {
   switch (Encoding) {
   case Encoding_UTF8:
-    return getNumBytesForUTF8(FirstChar);
+    return llvm::getNumBytesForUTF8(FirstChar);
   default:
     return 1;
   }
 }
 
 inline bool isOctDigit(char c) { return '0' <= c && c <= '7'; }
 
 inline bool isHexDigit(char c) {
inline unsigned getEscapeSequenceLength(StringRef Text) {
   }
   default:
     if (isOctDigit(Text[1])) {
       unsigned I = 1;
       while (I < Text.size() && I < 4 && isOctDigit(Text[I]))
         ++I;
       return I;
     }
-    return 1 + getNumBytesForUTF8(Text[1]);
+    return 1 + llvm::getNumBytesForUTF8(Text[1]);
   }
 }
 
 } // namespace encoding
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Frontend/TextDiagnostic.cpp

if (SourceLine[*i]=='\t') {
     expandedTab.assign(NumSpaces, ' ');
     return std::make_pair(expandedTab, true);
   }
 
   unsigned char const *begin, *end;
   begin = reinterpret_cast<unsigned char const *>(&*(SourceLine.begin() + *i));
   end = begin + (SourceLine.size() - *i);
   
-  if (isLegalUTF8Sequence(begin, end)) {
-    UTF32 c;
-    UTF32 *cptr = &c;
+  if (llvm::isLegalUTF8Sequence(begin, end)) {
+    llvm::UTF32 c;
+    llvm::UTF32 *cptr = &c;
     unsigned char const *original_begin = begin;
-    unsigned char const *cp_end = begin+getNumBytesForUTF8(SourceLine[*i]);
+    unsigned char const *cp_end =
+        begin + llvm::getNumBytesForUTF8(SourceLine[*i]);
 
-    ConversionResult res = ConvertUTF8toUTF32(&begin, cp_end, &cptr, cptr+1,
-                                              strictConversion);
+    llvm::ConversionResult res = llvm::ConvertUTF8toUTF32(
+        &begin, cp_end, &cptr, cptr + 1, llvm::strictConversion);
     (void)res;
-    assert(conversionOK==res);
+    assert(llvm::conversionOK == res);
     assert(0 < begin-original_begin
            && "we must be further along in the string now");
     *i += begin-original_begin;
 
     if (!llvm::sys::locale::isPrint(c)) {
       // If next character is valid UTF-8, but not printable
       SmallString<16> expandedCP("<U+>");
       while (c) {

clang/lib/Lex/Lexer.cpp

bool Lexer::tryConsumeIdentifierUCN(const char *&CurPtr, unsigned Size,
   else
     while (CurPtr != UCNPtr)
       (void)getAndAdvanceChar(CurPtr, Result);
   return true;
 }
 
 bool Lexer::tryConsumeIdentifierUTF8Char(const char *&CurPtr) {
   const char *UnicodePtr = CurPtr;
-  UTF32 CodePoint;
-  ConversionResult Result =
-      llvm::convertUTF8Sequence((const UTF8 **)&UnicodePtr,
-                                (const UTF8 *)BufferEnd,
+  llvm::UTF32 CodePoint;
+  llvm::ConversionResult Result =
+      llvm::convertUTF8Sequence((const llvm::UTF8 **)&UnicodePtr,
+                                (const llvm::UTF8 *)BufferEnd,
                                 &CodePoint,
-                                strictConversion);
-  if (Result != conversionOK ||
+                                llvm::strictConversion);
+  if (Result != llvm::conversionOK ||
       !isAllowedIDChar(static_cast<uint32_t>(CodePoint), LangOpts))
     return false;
 
   if (!isLexingRawMode())
     maybeDiagnoseIDCharCompat(PP->getDiagnostics(), CodePoint,
                               makeCharRange(*this, CurPtr, UnicodePtr),
                               /*IsFirst=*/false);
 
case '\\':
     break;
 
   default: {
     if (isASCII(Char)) {
       Kind = tok::unknown;
       break;
     }
 
-    UTF32 CodePoint;
+    llvm::UTF32 CodePoint;
 
     // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
     // an escaped newline.
     --CurPtr;
-    ConversionResult Status =
-        llvm::convertUTF8Sequence((const UTF8 **)&CurPtr,
-                                  (const UTF8 *)BufferEnd,
+    llvm::ConversionResult Status =
+        llvm::convertUTF8Sequence((const llvm::UTF8 **)&CurPtr,
+                                  (const llvm::UTF8 *)BufferEnd,
                                   &CodePoint,
-                                  strictConversion);
-    if (Status == conversionOK) {
+                                  llvm::strictConversion);
+    if (Status == llvm::conversionOK) {
       if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
         if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
           return true; // KeepWhitespaceMode
 
         // We only saw whitespace, so just try again with this lexer.
         // (We manually eliminate the tail call to avoid recursion.)
         goto LexNextToken;
       }

clang/lib/Lex/LiteralSupport.cpp

assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
          "only character widths of 1, 2, or 4 bytes supported");
 
   (void)UcnLen;
   assert((UcnLen== 4 || UcnLen== 8) && "only ucn length of 4 or 8 supported");
 
   if (CharByteWidth == 4) {
     // FIXME: Make the type of the result buffer correct instead of
     // using reinterpret_cast.
-    UTF32 *ResultPtr = reinterpret_cast<UTF32*>(ResultBuf);
+    llvm::UTF32 *ResultPtr = reinterpret_cast<llvm::UTF32*>(ResultBuf);
     *ResultPtr = UcnVal;
     ResultBuf += 4;
     return;
   }
 
   if (CharByteWidth == 2) {
     // FIXME: Make the type of the result buffer correct instead of
     // using reinterpret_cast.
-    UTF16 *ResultPtr = reinterpret_cast<UTF16*>(ResultBuf);
+    llvm::UTF16 *ResultPtr = reinterpret_cast<llvm::UTF16*>(ResultBuf);
 
     if (UcnVal <= (UTF32)0xFFFF) {
       *ResultPtr = UcnVal;
       ResultBuf += 2;
       return;
     }
 
     // Convert to UTF16.
while (begin != end) {
     if (begin[0] != '\\') {
       char const *start = begin;
       do {
         ++begin;
       } while (begin != end && *begin != '\\');
 
       char const *tmp_in_start = start;
       uint32_t *tmp_out_start = buffer_begin;
-      ConversionResult res =
-          ConvertUTF8toUTF32(reinterpret_cast<UTF8 const **>(&start),
-                             reinterpret_cast<UTF8 const *>(begin),
-                             &buffer_begin, buffer_end, strictConversion);
-      if (res != conversionOK) {
+      llvm::ConversionResult res =
+          llvm::ConvertUTF8toUTF32(reinterpret_cast<llvm::UTF8 const **>(&start),
+                             reinterpret_cast<llvm::UTF8 const *>(begin),
+                             &buffer_begin, buffer_end, llvm::strictConversion);
+      if (res != llvm::conversionOK) {
         // If we see bad encoding for unprefixed character literals, warn and
         // simply copy the byte values, for compatibility with gcc and
         // older versions of clang.
         bool NoErrorOnBadEncoding = isAscii();
         unsigned Msg = diag::err_bad_character_encoding;
         if (NoErrorOnBadEncoding)
           Msg = diag::warn_bad_character_encoding;
         PP.Diag(Loc, Msg);
if (ThisTokBuf[0] == 'R') {
         unsigned ResultChar =
           ProcessCharEscape(ThisTokBegin, ThisTokBuf, ThisTokEnd, hadError,
                             FullSourceLoc(StringToks[i].getLocation(), SM),
                             CharByteWidth*8, Diags, Features);
 
         if (CharByteWidth == 4) {
           // FIXME: Make the type of the result buffer correct instead of
           // using reinterpret_cast.
-          UTF32 *ResultWidePtr = reinterpret_cast<UTF32*>(ResultPtr);
+          llvm::UTF32 *ResultWidePtr = reinterpret_cast<llvm::UTF32*>(ResultPtr);
           *ResultWidePtr = ResultChar;
           ResultPtr += 4;
         } else if (CharByteWidth == 2) {
           // FIXME: Make the type of the result buffer correct instead of
           // using reinterpret_cast.
-          UTF16 *ResultWidePtr = reinterpret_cast<UTF16*>(ResultPtr);
+          llvm::UTF16 *ResultWidePtr = reinterpret_cast<llvm::UTF16*>(ResultPtr);
           *ResultWidePtr = ResultChar & 0xFFFF;
           ResultPtr += 2;
         } else {
           assert(CharByteWidth == 1 && "Unexpected char width");
           *ResultPtr++ = ResultChar & 0xFF;
         }
       }
     }
   }
 
   if (Pascal) {
     if (CharByteWidth == 4) {
       // FIXME: Make the type of the result buffer correct instead of
       // using reinterpret_cast.
-      UTF32 *ResultWidePtr = reinterpret_cast<UTF32*>(ResultBuf.data());
+      llvm::UTF32 *ResultWidePtr = reinterpret_cast<llvm::UTF32*>(ResultBuf.data());
       ResultWidePtr[0] = GetNumStringChars() - 1;
     } else if (CharByteWidth == 2) {
       // FIXME: Make the type of the result buffer correct instead of
       // using reinterpret_cast.
-      UTF16 *ResultWidePtr = reinterpret_cast<UTF16*>(ResultBuf.data());
+      llvm::UTF16 *ResultWidePtr = reinterpret_cast<llvm::UTF16*>(ResultBuf.data());
       ResultWidePtr[0] = GetNumStringChars() - 1;
     } else {
       assert(CharByteWidth == 1 && "Unexpected char width");
       ResultBuf[0] = GetNumStringChars() - 1;
     }
 
     // Verify that pascal strings aren't too large.
     if (GetStringLength() > 256) {
if (GetNumStringChars() > MaxChars)
         << SourceRange(StringToks.front().getLocation(),
                        StringToks.back().getLocation());
   }
 }
 
 static const char *resyncUTF8(const char *Err, const char *End) {
   if (Err == End)
     return End;
-  End = Err + std::min<unsigned>(getNumBytesForUTF8(*Err), End-Err);
+  End = Err + std::min<unsigned>(llvm::getNumBytesForUTF8(*Err), End-Err);
   while (++Err != End && (*Err & 0xC0) == 0x80)
     ;
   return Err;
 }
 
 /// \brief This function copies from Fragment, which is a sequence of bytes
 /// within Tok's contents (which begin at TokBegin) into ResultPtr.
 /// Performs widening for multi-byte characters.
 bool StringLiteralParser::CopyStringFragment(const Token &Tok,
                                              const char *TokBegin,
                                              StringRef Fragment) {
-  const UTF8 *ErrorPtrTmp;
+  const llvm::UTF8 *ErrorPtrTmp;
   if (ConvertUTF8toWide(CharByteWidth, Fragment, ResultPtr, ErrorPtrTmp))
     return false;
 
   // If we see bad encoding for unprefixed string literals, warn and
   // simply copy the byte values, for compatibility with gcc and older
   // versions of clang.
   bool NoErrorOnBadEncoding = isAscii();
   if (NoErrorOnBadEncoding) {

clang/lib/Sema/SemaChecking.cpp

if (!Literal || !Literal->isAscii()) {
     Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant)
       << Arg->getSourceRange();
     return true;
   }
 
   if (Literal->containsNonAsciiOrNull()) {
     StringRef String = Literal->getString();
     unsigned NumBytes = String.size();
-    SmallVector<UTF16, 128> ToBuf(NumBytes);
-    const UTF8 *FromPtr = (const UTF8 *)String.data();
-    UTF16 *ToPtr = &ToBuf[0];
-    
-    ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
-                                                 &ToPtr, ToPtr + NumBytes,
-                                                 strictConversion);
+    SmallVector<llvm::UTF16, 128> ToBuf(NumBytes);
+    const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
+    llvm::UTF16 *ToPtr = &ToBuf[0];
+    llvm::ConversionResult Result =
+        llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
+                                 ToPtr + NumBytes, llvm::strictConversion);
     // Check for conversion failure.
-    if (Result != conversionOK)
+    if (Result != llvm::conversionOK)
       Diag(Arg->getLocStart(),
            diag::warn_cfstring_truncated) << Arg->getSourceRange();
   }
   return false;
 }
 
 /// Check the arguments to '__builtin_va_start' or '__builtin_ms_va_start'
 /// for validity.  Emit an error and return true on failure; return false
CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex,
 
   StringRef Specifier(csStart, csLen);
 
   // If the specifier in non-printable, it could be the first byte of a UTF-8
   // sequence. In that case, print the UTF-8 code point. If not, print the byte
   // hex value.
   std::string CodePointStr;
   if (!llvm::sys::locale::isPrint(*csStart)) {
-    UTF32 CodePoint;
-    const UTF8 **B = reinterpret_cast<const UTF8 **>(&csStart);
-    const UTF8 *E =
-        reinterpret_cast<const UTF8 *>(csStart + csLen);
-    ConversionResult Result =
-        llvm::convertUTF8Sequence(B, E, &CodePoint, strictConversion);
+    llvm::UTF32 CodePoint;
+    const llvm::UTF8 **B = reinterpret_cast<const llvm::UTF8 **>(&csStart);
+    const llvm::UTF8 *E =
+        reinterpret_cast<const llvm::UTF8 *>(csStart + csLen);
+    llvm::ConversionResult Result =
+        llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
 
-    if (Result != conversionOK) {
+    if (Result != llvm::conversionOK) {
       unsigned char FirstChar = *csStart;
-      CodePoint = (UTF32)FirstChar;
+      CodePoint = (llvm::UTF32)FirstChar;
     }
 
     llvm::raw_string_ostream OS(CodePointStr);
     if (CodePoint < 256)
       OS << "\\x" << llvm::format("%02x", CodePoint);
     else if (CodePoint <= 0xFFFF)
       OS << "\\u" << llvm::format("%04x", CodePoint);
     else

clang/lib/Sema/SemaExpr.cpp

return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
                             TemplateArgs);
   }
 }
 
 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
                                     SmallString<32> &Target) {
   Target.resize(CharByteWidth * (Source.size() + 1));
   char *ResultPtr = &Target[0];
-  const UTF8 *ErrorPtr;
-  bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
+  const llvm::UTF8 *ErrorPtr;
+  bool success =
+      llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
   (void)success;
   assert(success);
   Target.resize(ResultPtr - &Target[0]);
 }
 
 ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
                                      PredefinedExpr::IdentType IT) {
   // Pick the current block, lambda, captured statement or function.

lldb/source/DataFormatters/StringPrinter.cpp

 
 template <>
 StringPrinter::StringPrinterBufferPointer<>
 GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer,
                                                          uint8_t *buffer_end,
                                                          uint8_t *&next) {
   StringPrinter::StringPrinterBufferPointer<> retval{nullptr};
 
-  unsigned utf8_encoded_len = getNumBytesForUTF8(*buffer);
+  unsigned utf8_encoded_len = llvm::getNumBytesForUTF8(*buffer);
 
   if (1 + buffer_end - buffer < utf8_encoded_len) {
     // I don't have enough bytes - print whatever I have left
     retval = {buffer, static_cast<size_t>(1 + buffer_end - buffer)};
     next = buffer_end + 1;
     return retval;
   }
 
case GetPrintableElementType::ASCII:
     };
   }
   llvm_unreachable("bad element type");
 }
 
 // use this call if you already have an LLDB-side buffer for the data
 template <typename SourceDataType>
 static bool DumpUTFBufferToStream(
-    ConversionResult (*ConvertFunction)(const SourceDataType **,
-                                        const SourceDataType *, UTF8 **, UTF8 *,
-                                        ConversionFlags),
+    llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
+                                              const SourceDataType *,
+                                              llvm::UTF8 **, llvm::UTF8 *,
+                                              llvm::ConversionFlags),
     const StringPrinter::ReadBufferAndDumpToStreamOptions &dump_options) {
   Stream &stream(*dump_options.GetStream());
   if (dump_options.GetPrefixToken() != 0)
     stream.Printf("%s", dump_options.GetPrefixToken());
   if (dump_options.GetQuote() != 0)
     stream.Printf("%c", dump_options.GetQuote());
   auto data(dump_options.GetData());
   auto source_size(dump_options.GetSourceSize());
if (zero_is_terminator) {
         }
         data_ptr++;
       }
 
       data_ptr = (const SourceDataType *)data.GetDataStart();
     }
 
     lldb::DataBufferSP utf8_data_buffer_sp;
-    UTF8 *utf8_data_ptr = nullptr;
-    UTF8 *utf8_data_end_ptr = nullptr;
+    llvm::UTF8 *utf8_data_ptr = nullptr;
+    llvm::UTF8 *utf8_data_end_ptr = nullptr;
 
     if (ConvertFunction) {
       utf8_data_buffer_sp.reset(new DataBufferHeap(4 * bufferSPSize, 0));
-      utf8_data_ptr = (UTF8 *)utf8_data_buffer_sp->GetBytes();
+      utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
       utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
       ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
-                      utf8_data_end_ptr, lenientConversion);
+                      utf8_data_end_ptr, llvm::lenientConversion);
       if (false == zero_is_terminator)
         utf8_data_end_ptr = utf8_data_ptr;
+      // needed because the ConvertFunction will change the value of the
+      // data_ptr.
       utf8_data_ptr =
-          (UTF8 *)utf8_data_buffer_sp->GetBytes(); // needed because the
-                                                   // ConvertFunction will
-                                                   // change the value of the
-                                                   // data_ptr
+          (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
     } else {
       // just copy the pointers - the cast is necessary to make the compiler
       // happy
       // but this should only happen if we are reading UTF8 data
-      utf8_data_ptr =
-          const_cast<UTF8 *>(reinterpret_cast<const UTF8 *>(data_ptr));
-      utf8_data_end_ptr =
-          const_cast<UTF8 *>(reinterpret_cast<const UTF8 *>(data_end_ptr));
+      utf8_data_ptr = const_cast<llvm::UTF8 *>(
+          reinterpret_cast<const llvm::UTF8 *>(data_ptr));
+      utf8_data_end_ptr = const_cast<llvm::UTF8 *>(
+          reinterpret_cast<const llvm::UTF8 *>(data_end_ptr));
     }
 
     const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
     lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
     if (escape_non_printables) {
       if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
         escaping_callback = language->GetStringPrinterEscapingHelper(
             lldb_private::formatters::StringPrinter::GetPrintableElementType::
if (is_truncated)
     options.GetStream()->Printf("...");
 
   return true;
 }
 
 template <typename SourceDataType>
 static bool ReadUTFBufferAndDumpToStream(
     const StringPrinter::ReadStringAndDumpToStreamOptions &options,
-    ConversionResult (*ConvertFunction)(const SourceDataType **,
-                                        const SourceDataType *, UTF8 **, UTF8 *,
-                                        ConversionFlags)) {
+    llvm::ConversionResult (*ConvertFunction)(const SourceDataType **,
+                                              const SourceDataType *,
+                                              llvm::UTF8 **, llvm::UTF8 *,
+                                              llvm::ConversionFlags)) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
   if (options.GetLocation() == 0 ||
       options.GetLocation() == LLDB_INVALID_ADDRESS)
     return false;
 
   lldb::ProcessSP process_sp(options.GetProcessSP());
 
static bool ReadUTFBufferAndDumpToStream(
 
   return DumpUTFBufferToStream(ConvertFunction, dump_options);
 }
 
 template <>
 bool StringPrinter::ReadStringAndDumpToStream<
     StringPrinter::StringElementType::UTF8>(
     const ReadStringAndDumpToStreamOptions &options) {
-  return ReadUTFBufferAndDumpToStream<UTF8>(options, nullptr);
+  return ReadUTFBufferAndDumpToStream<llvm::UTF8>(options, nullptr);
 }
 
 template <>
 bool StringPrinter::ReadStringAndDumpToStream<
     StringPrinter::StringElementType::UTF16>(
     const ReadStringAndDumpToStreamOptions &options) {
-  return ReadUTFBufferAndDumpToStream<UTF16>(options, ConvertUTF16toUTF8);
+  return ReadUTFBufferAndDumpToStream<llvm::UTF16>(options,
+                                                   llvm::ConvertUTF16toUTF8);
 }
 
 template <>
 bool StringPrinter::ReadStringAndDumpToStream<
     StringPrinter::StringElementType::UTF32>(
     const ReadStringAndDumpToStreamOptions &options) {
-  return ReadUTFBufferAndDumpToStream<UTF32>(options, ConvertUTF32toUTF8);
+  return ReadUTFBufferAndDumpToStream<llvm::UTF32>(options,
+                                                   llvm::ConvertUTF32toUTF8);
 }
 
 template <>
 bool StringPrinter::ReadBufferAndDumpToStream<
     StringPrinter::StringElementType::UTF8>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
-  return DumpUTFBufferToStream<UTF8>(nullptr, options);
+  return DumpUTFBufferToStream<llvm::UTF8>(nullptr, options);
 }
 
 template <>
 bool StringPrinter::ReadBufferAndDumpToStream<
     StringPrinter::StringElementType::ASCII>(
     const ReadBufferAndDumpToStreamOptions &options) {
   // treat ASCII the same as UTF8
   // FIXME: can we optimize ASCII some more?
   return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
 }
 
 template <>
 bool StringPrinter::ReadBufferAndDumpToStream<
     StringPrinter::StringElementType::UTF16>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
-  return DumpUTFBufferToStream(ConvertUTF16toUTF8, options);
+  return DumpUTFBufferToStream(llvm::ConvertUTF16toUTF8, options);
 }
 
 template <>
 bool StringPrinter::ReadBufferAndDumpToStream<
     StringPrinter::StringElementType::UTF32>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
-  return DumpUTFBufferToStream(ConvertUTF32toUTF8, options);
+  return DumpUTFBufferToStream(llvm::ConvertUTF32toUTF8, options);
 }
 
 } // namespace formatters
 
 } // namespace lldb_private

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

 lldb_private::minidump::parseMinidumpString(llvm::ArrayRef<uint8_t> &data) {
   std::string result;
 
   const uint32_t *source_length;
   Error error = consumeObject(data, source_length);
   if (error.Fail() || *source_length > data.size() || *source_length % 2 != 0)
     return llvm::None;
 
-  auto source_start = reinterpret_cast<const UTF16 *>(data.data());
+  auto source_start = reinterpret_cast<const llvm::UTF16 *>(data.data());
   // source_length is the length of the string in bytes
   // we need the length of the string in UTF-16 characters/code points (16 bits
   // per char)
   // that's why it's divided by 2
   const auto source_end = source_start + (*source_length) / 2;
   // resize to worst case length
   result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT * (*source_length) / 2);
-  auto result_start = reinterpret_cast<UTF8 *>(&result[0]);
+  auto result_start = reinterpret_cast<llvm::UTF8 *>(&result[0]);
   const auto result_end = result_start + result.size();
-  ConvertUTF16toUTF8(&source_start, source_end, &result_start, result_end,
-                     strictConversion);
+  llvm::ConvertUTF16toUTF8(&source_start, source_end, &result_start, result_end,
+                           llvm::strictConversion);
   const auto result_size =
-      std::distance(reinterpret_cast<UTF8 *>(&result[0]), result_start);
+      std::distance(reinterpret_cast<llvm::UTF8 *>(&result[0]), result_start);
   result.resize(result_size); // shrink to actual length
 
   return result;
 }
 
 // MinidumpThread
 const MinidumpThread *MinidumpThread::Parse(llvm::ArrayRef<uint8_t> &data) {
   const MinidumpThread *thread = nullptr;

llvm/include/llvm/Support/ConvertUTF.h

/* ---------------------------------------------------------------------
     Rev History: Rick McGowan, fixes & updates May 2001.
          Fixes & updates, Sept 2001.
 
 ------------------------------------------------------------------------ */
 
 #ifndef LLVM_SUPPORT_CONVERTUTF_H
 #define LLVM_SUPPORT_CONVERTUTF_H
 
+#include <string>
+#include <cstddef>
+
+// Wrap everything in namespace llvm so that programs can link with llvm and
+// their own version of the unicode libraries.
+
+namespace llvm {
+
 /* ---------------------------------------------------------------------
     The following 4 definitions are compiler-specific.
     The C standard does not guarantee that wchar_t has at least
     16 bits, so wchar_t is no less portable than unsigned short!
     All should be unsigned values to avoid sign extension during
     bit mask & shift operations.
 ------------------------------------------------------------------------ */
 
typedef enum {
   sourceIllegal           /* source sequence is illegal/malformed */
 } ConversionResult;
 
 typedef enum {
   strictConversion = 0,
   lenientConversion
 } ConversionFlags;
 
-/* This is for C++ and does no harm in C */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 ConversionResult ConvertUTF8toUTF16 (
   const UTF8** sourceStart, const UTF8* sourceEnd,
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
 /**
  * Convert a partial UTF8 sequence to UTF32.  If the sequence ends in an
  * incomplete code unit sequence, returns \c sourceExhausted.
  */
ConversionResult ConvertUTF32toUTF16 (
   UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
 Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
 
 Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd);
 
 unsigned getNumBytesForUTF8(UTF8 firstByte);
 
-#ifdef __cplusplus
-}
-
 /*************************************************************************/
 /* Below are LLVM-specific wrappers of the functions above. */
 
-#include <string>
-#include <cstddef>
-
-namespace llvm {
 template <typename T> class ArrayRef;
 template <typename T> class SmallVectorImpl;
 class StringRef;
 
 /**
  * Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on
  * WideCharWidth. The converted data is written to ResultPtr, which needs to
  * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success,

  * \returns true on success
  */
 bool convertUTF8ToUTF16String(StringRef SrcUTF8,
                               SmallVectorImpl<UTF16> &DstUTF16);
 
 } /* end namespace llvm */
 
 #endif
-
-/* --------------------------------------------------------------------- */
-
-#endif

llvm/lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   Allocator.cpp
   BlockFrequency.cpp
   BranchProbability.cpp
   CachePruning.cpp
   circular_raw_ostream.cpp
   COM.cpp
   CommandLine.cpp
   Compression.cpp
-  ConvertUTF.c
+  ConvertUTF.cpp
   ConvertUTFWrapper.cpp
   CrashRecoveryContext.cpp
   DataExtractor.cpp
   DataStream.cpp
   Debug.cpp
   DeltaAlgorithm.cpp
   DAGDeltaAlgorithm.cpp
   Dwarf.cpp

llvm/lib/Support/ConvertUTF.cpp

 
 
 #include "llvm/Support/ConvertUTF.h"
 #ifdef CVTUTF_DEBUG
 #include <stdio.h>
 #endif
 #include <assert.h>
 
+namespace llvm {
+
 static const int halfShift  = 10; /* used for shifting by 10 bits */
 
 static const UTF32 halfBase = 0x0010000UL;
 static const UTF32 halfMask = 0x3FFUL;
 
 #define UNI_SUR_HIGH_START  (UTF32)0xD800
 #define UNI_SUR_HIGH_END    (UTF32)0xDBFF
 #define UNI_SUR_LOW_START   (UTF32)0xDC00
 #define UNI_SUR_LOW_END     (UTF32)0xDFFF
-#define false      0
-#define true        1
 
 /* --------------------------------------------------------------------- */
 
 /*
  * Index into the table below with the first byte of a UTF-8 sequence to
  * get the number of trailing bytes that are supposed to follow it.
  * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
  * left as-is for anyone who may want to do such conversion, which was
are equivalent to the following loop:
                 --tmpBytesToRead;
                 if (tmpBytesToRead) ch <<= 6;
             } while (tmpBytesToRead > 0);
         }
     In UTF-8 writing code, the switches on "bytesToWrite" are
     similarly unrolled loops.
 
    --------------------------------------------------------------------- */
+
+} // namespace llvm