[fuchsia] Add line buffering in RawWrite

[jakehehrlich]

Summary

This change causes RawWrite to buffer upto 128 bytes or until a line is reached. This helps group calls into more readable lines.

[mcgrathr]

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

415

Ideally you'd buffer multiple short lines when they're all in the same call and do a single __sanitizer_log_write call.
To really flush only when necessary you'd compact the buffer if there's a partial line left after a flush or do some sort of ring-buffer arrangement.
You can do a bit better than the by-char loop using internal_strchr (which might get optimized though it isn't now).

[jakehehrlich]

Modified to group multiple lines into a single flush but still flush at least once if a newline is found.

[mcgrathr]

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

419

if lastNewline was null now it's line and so this writes a count of 0.
Seems like the code would be simpler if lastNewline were an index too.

428

This seems like an odd way to describe it. The behavior is just "Flush all complete lines before returning".

[jakehehrlich]

Switched to use index. Fixed to print out full buffer in case no newline exists.

[mcgrathr]

lgtm

[jakehehrlich]

Landed in rL333136

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

if (status == ZX_OK) {
     }
     _zx_handle_close(vmo);
   }
   if (status != ZX_OK && errno_p) *errno_p = status;
   return status == ZX_OK;
 }
 
 void RawWrite(const char *buffer) {
-  __sanitizer_log_write(buffer, internal_strlen(buffer));
+  constexpr size_t size = 128;
+  static _Thread_local char line[size];
+  static _Thread_local char *lastNewline = nullptr;
+  static _Thread_local size_t cur = 0;
+
+  while (*buffer) {
+    if (cur >= size) {
+      if (lastNewline == nullptr)
+        lastNewline = line;
+      __sanitizer_log_write(line, lastNewline - line);
+      internal_memmove(line, lastNewline, line + size - lastNewline);
+      cur = 0;
+      lastNewline = nullptr;
+    }
+    if (*buffer == '\n')
+      lastNewline = line + cur;
+    line[cur++] = *buffer++;
+  }
+  // Flush if there's a newline in the buffer but the buffer isn't full.
+  // This prevents the last few lines from not being flushed.
+  if (lastNewline != nullptr) {
+    __sanitizer_log_write(line, lastNewline - line);
+    internal_memmove(line, lastNewline, line + cur - lastNewline);
+    cur = 0;
+    lastNewline = nullptr;
+  }
 }
 
 void CatastrophicErrorWrite(const char *buffer, uptr length) {
   __sanitizer_log_write(buffer, length);
 }
 
 char **StoredArgv;
 char **StoredEnviron;