[NFC][scudo] Make formatString return uptr

[cryptoad]

compiler-rt/lib/scudo/standalone/string_utils.cpp

104

Width is int and Res is an uptr here, that might cause issues.

[vitalybuka]

compiler-rt/lib/scudo/standalone/string_utils.cpp

104

Already notices by ruining tests :)
I will abandon.

compiler-rt/lib/scudo/standalone/string_utils.h

public:
   void append(const char *Format, ...);
   void output() const { outputRaw(String.data()); }
 
 private:
   Vector<char> String;
   uptr Length = 0;
 };
 
-int formatString(char *Buffer, uptr BufferLength, const char *Format, ...);
+uptr formatString(char *Buffer, uptr BufferLength, const char *Format, ...);
 void Printf(const char *Format, ...);
 
 } // namespace scudo
 
 #endif // SCUDO_STRING_UTILS_H_

compiler-rt/lib/scudo/standalone/string_utils.cpp

 //===-- string_utils.cpp ----------------------------------------*- C++ -*-===//
 //
 // 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 "string_utils.h"
 #include "common.h"
 
 #include <stdarg.h>
 #include <string.h>
 
 namespace scudo {
 
-static int appendChar(char **Buffer, const char *BufferEnd, char C) {
+static uptr appendChar(char **Buffer, const char *BufferEnd, char C) {
   if (*Buffer < BufferEnd) {
     **Buffer = C;
     (*Buffer)++;
   }
   return 1;
 }
 
 // Appends number in a given Base to buffer. If its length is less than
 // |MinNumberLength|, it is padded with leading zeroes or spaces, depending
 // on the value of |PadWithZero|.
-static int appendNumber(char **Buffer, const char *BufferEnd, u64 AbsoluteValue,
-                        u8 Base, u8 MinNumberLength, bool PadWithZero,
-                        bool Negative, bool Upper) {
+static uptr appendNumber(char **Buffer, const char *BufferEnd,
+                         u64 AbsoluteValue, u8 Base, u8 MinNumberLength,
+                         bool PadWithZero, bool Negative, bool Upper) {
   constexpr uptr MaxLen = 30;
   RAW_CHECK(Base == 10 || Base == 16);
   RAW_CHECK(Base == 10 || !Negative);
   RAW_CHECK(AbsoluteValue || !Negative);
   RAW_CHECK(MinNumberLength < MaxLen);
-  int Res = 0;
+  uptr Res = 0;
   if (Negative && MinNumberLength)
     --MinNumberLength;
   if (Negative && PadWithZero)
     Res += appendChar(Buffer, BufferEnd, '-');
   uptr NumBuffer[MaxLen];
   int Pos = 0;
   do {
     RAW_CHECK_MSG(static_cast<uptr>(Pos) < MaxLen,
for (; Pos >= 0; Pos--) {
     char Digit = static_cast<char>(NumBuffer[Pos]);
     Digit = static_cast<char>((Digit < 10) ? '0' + Digit
                                            : (Upper ? 'A' : 'a') + Digit - 10);
     Res += appendChar(Buffer, BufferEnd, Digit);
   }
   return Res;
 }
 
-static int appendUnsigned(char **Buffer, const char *BufferEnd, u64 Num,
+static uptr appendUnsigned(char **Buffer, const char *BufferEnd, u64 Num,
                            u8 Base, u8 MinNumberLength, bool PadWithZero,
                            bool Upper) {
   return appendNumber(Buffer, BufferEnd, Num, Base, MinNumberLength,
                       PadWithZero, /*Negative=*/false, Upper);
 }
 
-static int appendSignedDecimal(char **Buffer, const char *BufferEnd, s64 Num,
+static uptr appendSignedDecimal(char **Buffer, const char *BufferEnd, s64 Num,
                                 u8 MinNumberLength, bool PadWithZero) {
   const bool Negative = (Num < 0);
   const u64 UnsignedNum = (Num == INT64_MIN)
                               ? static_cast<u64>(INT64_MAX) + 1
                               : static_cast<u64>(Negative ? -Num : Num);
   return appendNumber(Buffer, BufferEnd, UnsignedNum, 10, MinNumberLength,
                       PadWithZero, Negative, /*Upper=*/false);
 }
 
 // Use the fact that explicitly requesting 0 Width (%0s) results in UB and
 // interpret Width == 0 as "no Width requested":
 // Width == 0 - no Width requested
 // Width  < 0 - left-justify S within and pad it to -Width chars, if necessary
 // Width  > 0 - right-justify S, not implemented yet
-static int appendString(char **Buffer, const char *BufferEnd, int Width,
+static uptr appendString(char **Buffer, const char *BufferEnd, int Width,
                          int MaxChars, const char *S) {
   if (!S)
     S = "<null>";
-  int Res = 0;
+  uptr Res = 0;
   for (; *S; S++) {
     if (MaxChars >= 0 && Res >= MaxChars)
       break;
     Res += appendChar(Buffer, BufferEnd, *S);
   }
   // Only the left justified strings are supported.
   while (Width < -Res)
     Res += appendChar(Buffer, BufferEnd, ' ');
   return Res;
 }
 
-static int appendPointer(char **Buffer, const char *BufferEnd, u64 ptr_value) {
-  int Res = 0;
+static uptr appendPointer(char **Buffer, const char *BufferEnd, u64 ptr_value) {
+  uptr Res = 0;
   Res += appendString(Buffer, BufferEnd, 0, -1, "0x");
   Res += appendUnsigned(Buffer, BufferEnd, ptr_value, 16,
                         SCUDO_POINTER_FORMAT_LENGTH, /*PadWithZero=*/true,
                         /*Upper=*/false);
   return Res;
 }
 
-static int formatString(char *Buffer, uptr BufferLength, const char *Format,
+static uptr formatString(char *Buffer, uptr BufferLength, const char *Format,
                          va_list Args) {
   static const char *PrintfFormatsHelp =
       "Supported formatString formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
       "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
   RAW_CHECK(Format);
   RAW_CHECK(BufferLength > 0);
   const char *BufferEnd = &Buffer[BufferLength - 1];
   const char *Cur = Format;
-  int Res = 0;
+  uptr Res = 0;
   for (; *Cur; Cur++) {
     if (*Cur != '%') {
       Res += appendChar(&Buffer, BufferEnd, *Cur);
       continue;
     }
     Cur++;
     const bool LeftJustified = *Cur == '-';
     if (LeftJustified)
for (; *Cur; Cur++) {
     }
     }
   }
   RAW_CHECK(Buffer <= BufferEnd);
   appendChar(&Buffer, BufferEnd + 1, '\0');
   return Res;
 }
 
-int formatString(char *Buffer, uptr BufferLength, const char *Format, ...) {
+uptr formatString(char *Buffer, uptr BufferLength, const char *Format, ...) {
   va_list Args;
   va_start(Args, Format);
-  int Res = formatString(Buffer, BufferLength, Format, Args);
+  uptr Res = formatString(Buffer, BufferLength, Format, Args);
   va_end(Args);
   return Res;
 }
 
 void ScopedString::append(const char *Format, va_list Args) {
   RAW_CHECK(Length <= String.size());
   va_list ArgsCopy;
   va_copy(ArgsCopy, Args);
   // formatString doesn't currently support a null buffer or zero buffer length,
   // so in order to get the resulting formatted string length, we use a one-char
   // buffer.
   char C[1];
-  const uptr AdditionalLength =
-      static_cast<uptr>(formatString(C, sizeof(C), Format, Args)) + 1;
+  const uptr AdditionalLength = formatString(C, sizeof(C), Format, Args) + 1;
   String.resize(Length + AdditionalLength);
   formatString(String.data() + Length, AdditionalLength, Format, ArgsCopy);
   va_end(ArgsCopy);
   Length = strlen(String.data());
   RAW_CHECK(Length < String.size());
 }
 
 FORMAT(2, 3)