TheRock/compiler/amd-llvm/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 {

// 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|.
void ScopedString::appendNumber(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);
  if (Negative && MinNumberLength)
    --MinNumberLength;
  if (Negative && PadWithZero) {
    String.push_back('-');
  }
  uptr NumBuffer[MaxLen];
  int Pos = 0;
  do {
    RAW_CHECK_MSG(static_cast<uptr>(Pos) < MaxLen,
                  "appendNumber buffer overflow");
    NumBuffer[Pos++] = static_cast<uptr>(AbsoluteValue % Base);
    AbsoluteValue /= Base;
  } while (AbsoluteValue > 0);
  if (Pos < MinNumberLength) {
    memset(&NumBuffer[Pos], 0,
           sizeof(NumBuffer[0]) * static_cast<uptr>(MinNumberLength - Pos));
    Pos = MinNumberLength;
  }
  RAW_CHECK(Pos > 0);
  Pos--;
  for (; Pos >= 0 && NumBuffer[Pos] == 0; Pos--) {
    char c = (PadWithZero || Pos == 0) ? '0' : ' ';
    String.push_back(c);
  }
  if (Negative && !PadWithZero)
    String.push_back('-');
  for (; Pos >= 0; Pos--) {
    char Digit = static_cast<char>(NumBuffer[Pos]);
    Digit = static_cast<char>((Digit < 10) ? '0' + Digit
                                           : (Upper ? 'A' : 'a') + Digit - 10);
    String.push_back(Digit);
  }
}

void ScopedString::appendUnsigned(u64 Num, u8 Base, u8 MinNumberLength,
                                  bool PadWithZero, bool Upper) {
  appendNumber(Num, Base, MinNumberLength, PadWithZero, /*Negative=*/false,
               Upper);
}

void ScopedString::appendSignedDecimal(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);
  appendNumber(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
void ScopedString::appendString(int Width, int MaxChars, const char *S) {
  if (!S)
    S = "<null>";
  int NumChars = 0;
  for (; *S; S++) {
    if (MaxChars >= 0 && NumChars >= MaxChars)
      break;
    String.push_back(*S);
    NumChars++;
  }
  if (Width < 0) {
    // Only left justification supported.
    Width = -Width - NumChars;
    while (Width-- > 0)
      String.push_back(' ');
  }
}

void ScopedString::appendPointer(u64 ptr_value) {
  appendString(0, -1, "0x");
  appendUnsigned(ptr_value, 16, SCUDO_POINTER_FORMAT_LENGTH,
                 /*PadWithZero=*/true,
                 /*Upper=*/false);
}

void ScopedString::vappend(const char *Format, va_list &Args) {
  // Since the string contains the '\0' terminator, put our size before it
  // so that push_back calls work correctly.
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);

  static const char *PrintfFormatsHelp =
      "Supported formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
      "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
  RAW_CHECK(Format);
  const char *Cur = Format;
  for (; *Cur; Cur++) {
    if (*Cur != '%') {
      String.push_back(*Cur);
      continue;
    }
    Cur++;
    const bool LeftJustified = *Cur == '-';
    if (LeftJustified)
      Cur++;
    bool HaveWidth = (*Cur >= '0' && *Cur <= '9');
    const bool PadWithZero = (*Cur == '0');
    u8 Width = 0;
    if (HaveWidth) {
      while (*Cur >= '0' && *Cur <= '9')
        Width = static_cast<u8>(Width * 10 + *Cur++ - '0');
    }
    const bool HavePrecision = (Cur[0] == '.' && Cur[1] == '*');
    int Precision = -1;
    if (HavePrecision) {
      Cur += 2;
      Precision = va_arg(Args, int);
    }
    const bool HaveZ = (*Cur == 'z');
    Cur += HaveZ;
    const bool HaveLL = !HaveZ && (Cur[0] == 'l' && Cur[1] == 'l');
    Cur += HaveLL * 2;
    s64 DVal;
    u64 UVal;
    const bool HaveLength = HaveZ || HaveLL;
    const bool HaveFlags = HaveWidth || HaveLength;
    // At the moment only %s supports precision and left-justification.
    CHECK(!((Precision >= 0 || LeftJustified) && *Cur != 's'));
    switch (*Cur) {
    case 'd': {
      DVal = HaveLL  ? va_arg(Args, s64)
             : HaveZ ? va_arg(Args, sptr)
                     : va_arg(Args, int);
      appendSignedDecimal(DVal, Width, PadWithZero);
      break;
    }
    case 'u':
    case 'x':
    case 'X': {
      UVal = HaveLL  ? va_arg(Args, u64)
             : HaveZ ? va_arg(Args, uptr)
                     : va_arg(Args, unsigned);
      const bool Upper = (*Cur == 'X');
      appendUnsigned(UVal, (*Cur == 'u') ? 10 : 16, Width, PadWithZero, Upper);
      break;
    }
    case 'p': {
      RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp);
      appendPointer(va_arg(Args, uptr));
      break;
    }
    case 's': {
      RAW_CHECK_MSG(!HaveLength, PrintfFormatsHelp);
      // Only left-justified Width is supported.
      CHECK(!HaveWidth || LeftJustified);
      appendString(LeftJustified ? -Width : Width, Precision,
                   va_arg(Args, char *));
      break;
    }
    case 'c': {
      RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp);
      String.push_back(static_cast<char>(va_arg(Args, int)));
      break;
    }
    // In Scudo, `s64`/`u64` are supposed to use `lld` and `llu` respectively.
    // However, `-Wformat` doesn't know we have a different parser for those
    // placeholders and it keeps complaining the type mismatch on 64-bit
    // platform which uses `ld`/`lu` for `s64`/`u64`. Therefore, in order to
    // silence the warning, we turn to use `PRId64`/`PRIu64` for printing
    // `s64`/`u64` and handle the `ld`/`lu` here.
    case 'l': {
      ++Cur;
      RAW_CHECK(*Cur == 'd' || *Cur == 'u');

      if (*Cur == 'd') {
        DVal = va_arg(Args, s64);
        appendSignedDecimal(DVal, Width, PadWithZero);
      } else {
        UVal = va_arg(Args, u64);
        appendUnsigned(UVal, 10, Width, PadWithZero, false);
      }

      break;
    }
    case '%': {
      RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp);
      String.push_back('%');
      break;
    }
    default: {
      RAW_CHECK_MSG(false, PrintfFormatsHelp);
    }
    }
  }
  ensureNullTerminated();
}

void ScopedString::append(const char *Format, ...) {
  va_list Args;
  va_start(Args, Format);
  vappend(Format, Args);
  va_end(Args);
}

void ScopedString::append(const s32 Value) {
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);
  appendSignedDecimal(static_cast<s64>(Value), 0, false);
  ensureNullTerminated();
}

void ScopedString::append(const s64 Value) {
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);
  appendSignedDecimal(Value, 0, false);
  ensureNullTerminated();
}

void ScopedString::append(const u32 Value) {
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);
  appendUnsigned(static_cast<u64>(Value), 10, 0, false, false);
  ensureNullTerminated();
}

void ScopedString::append(const u64 Value) {
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);
  appendUnsigned(Value, 10, 0, false, false);
  ensureNullTerminated();
}

void ScopedString::append(const bool Value) {
  DCHECK(String.size() > 0);
  String.resize(String.size() - 1);
  appendString(0, -1, Value ? "true" : "false");
  ensureNullTerminated();
}

void ScopedString::ensureNullTerminated() {
  String.push_back('\0');
  if (String.back() != '\0') {
    // String truncated, make sure the string is terminated properly.
    // This can happen if there is no more memory when trying to resize
    // the string.
    String.back() = '\0';
  }
}

void Printf(const char *Format, ...) {
  va_list Args;
  va_start(Args, Format);
  ScopedString Msg;
  Msg.vappend(Format, Args);
  outputRaw(Msg.data());
  va_end(Args);
}

} // namespace scudo