Speedup some unicode rendering

[serge-sans-paille]

Summary

Use a short path for column width computation for ascii characters. Especially relevant for llvm-objdump.

before:

% time ./bin/llvm-objdump -D  -j .text /lib/libc.so.6 >/dev/null
./bin/llvm-objdump -D -j .text /lib/libc.so.6 > /dev/null  0.75s user 0.01s system 99% cpu 0.757 total

after:

% time ./bin/llvm-objdump -D  -j .text /lib/libc.so.6 >/dev/null
./bin/llvm-objdump -D -j .text /lib/libc.so.6 > /dev/null  0.37s user 0.01s system 99% cpu 0.378 total

[aguinet]

llvm/lib/Support/Unicode.cpp

352

According to isprint man page, the result depends on the current locale. Is this the behavior we want? Maybe checking for the printable ASCII character range "by hand" would make this code more portable?

[serge-sans-paille]

llvm/lib/Support/Unicode.cpp

352

correct, I'll add that.

[serge-sans-paille]

Make the ascii test for isprintable locale-independent

[serge-sans-paille]

Update test

llvm/lib/Support/Unicode.cpp

static inline int charWidth(int UCS)
   };
   static const UnicodeCharSet DoubleWidthCharacters(DoubleWidthCharacterRanges);
 
   if (DoubleWidthCharacters.contains(UCS))
     return 2;
   return 1;
 }
 
+static bool isprintableascii(char c) { return c > 31 && c < 127; }
+
 int columnWidthUTF8(StringRef Text) {
   unsigned ColumnWidth = 0;
   unsigned Length;
   for (size_t i = 0, e = Text.size(); i < e; i += Length) {
     Length = getNumBytesForUTF8(Text[i]);
+
+    // fast path for ASCII characters
+    if (Length == 1) {
+      if (!isprintableascii(Text[i]))
+        return ErrorNonPrintableCharacter;
+      ColumnWidth += 1;
+      continue;
+    }
+
     if (Length <= 0 || i + Length > Text.size())
       return ErrorInvalidUTF8;
     UTF32 buf[1];
     const UTF8 *Start = reinterpret_cast<const UTF8 *>(Text.data() + i);
     UTF32 *Target = &buf[0];
     if (conversionOK != ConvertUTF8toUTF32(&Start, Start + Length, &Target,
                                            Target + 1, strictConversion))
       return ErrorInvalidUTF8;

llvm/unittests/Support/UnicodeTest.cpp

 //===- unittests/Support/UnicodeTest.cpp - Unicode.h tests ----------------===//
 //
 // 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 "llvm/Support/Unicode.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace sys {
 namespace unicode {
 namespace {
 
 TEST(Unicode, columnWidthUTF8) {
   EXPECT_EQ(0, columnWidthUTF8(""));
   EXPECT_EQ(1, columnWidthUTF8(" "));
   EXPECT_EQ(1, columnWidthUTF8("a"));
   EXPECT_EQ(1, columnWidthUTF8("~"));
 
   EXPECT_EQ(6, columnWidthUTF8("abcdef"));
 
   EXPECT_EQ(-1, columnWidthUTF8("\x01"));
+  EXPECT_EQ(-1, columnWidthUTF8("\t"));
   EXPECT_EQ(-1, columnWidthUTF8("aaaaaaaaaa\x01"));
   EXPECT_EQ(-1, columnWidthUTF8("\342\200\213")); // 200B ZERO WIDTH SPACE
 
   // 00AD SOFT HYPHEN is displayed on most terminals as a space or a dash. Some
   // text editors display it only when a line is broken at it, some use it as a
   // line-break hint, but don't display. We choose terminal-oriented
   // interpretation.
   EXPECT_EQ(1, columnWidthUTF8("\302\255"));
TEST(Unicode, isPrintable) {
   EXPECT_FALSE(isPrintable(0x0378)); // <reserved-0378>..<reserved-0379>
 
   EXPECT_FALSE(isPrintable(0x0600)); // ARABIC NUMBER SIGN
 
   EXPECT_FALSE(isPrintable(0x1FFFF)); // <reserved-1F774>..<noncharacter-1FFFF>
   EXPECT_TRUE(isPrintable(0x20000));  // CJK UNIFIED IDEOGRAPH-20000
 
   EXPECT_FALSE(isPrintable(0x10FFFF)); // noncharacter
+
+  // test the validity of a fast path in columnWidthUTF8
+  for (unsigned char c = 0; c < 128; ++c) {
+    const UTF8 buf8[2] = {c, 0};
+    const UTF8 *Target8 = &buf8[0];
+    UTF32 buf32[1];
+    UTF32 *Target32 = &buf32[0];
+    auto status = ConvertUTF8toUTF32(&Target8, Target8 + 1, &Target32,
+                                     Target32 + 1, strictConversion);
+    EXPECT_TRUE(status == conversionOK);
+    EXPECT_TRUE((columnWidthUTF8(reinterpret_cast<const char *>(buf8)) == 1) ==
+                (bool)isPrintable(buf32[0]));
+  }
 }
 
 } // namespace
 } // namespace unicode
 } // namespace sys
 } // namespace llvm