1 //===-- string_utils.cpp ----------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "string_utils.h" 10 #include "common.h" 11 12 #include <stdarg.h> 13 #include <string.h> 14 15 namespace scudo { 16 17 static int appendChar(char **Buffer, const char *BufferEnd, char C) { 18 if (*Buffer < BufferEnd) { 19 **Buffer = C; 20 (*Buffer)++; 21 } 22 return 1; 23 } 24 25 // Appends number in a given Base to buffer. If its length is less than 26 // |MinNumberLength|, it is padded with leading zeroes or spaces, depending 27 // on the value of |PadWithZero|. 28 static int appendNumber(char **Buffer, const char *BufferEnd, u64 AbsoluteValue, 29 u8 Base, u8 MinNumberLength, bool PadWithZero, 30 bool Negative, bool Upper) { 31 constexpr uptr MaxLen = 30; 32 RAW_CHECK(Base == 10 || Base == 16); 33 RAW_CHECK(Base == 10 || !Negative); 34 RAW_CHECK(AbsoluteValue || !Negative); 35 RAW_CHECK(MinNumberLength < MaxLen); 36 int Res = 0; 37 if (Negative && MinNumberLength) 38 --MinNumberLength; 39 if (Negative && PadWithZero) 40 Res += appendChar(Buffer, BufferEnd, '-'); 41 uptr NumBuffer[MaxLen]; 42 int Pos = 0; 43 do { 44 RAW_CHECK_MSG(static_cast<uptr>(Pos) < MaxLen, 45 "appendNumber buffer overflow"); 46 NumBuffer[Pos++] = static_cast<uptr>(AbsoluteValue % Base); 47 AbsoluteValue /= Base; 48 } while (AbsoluteValue > 0); 49 if (Pos < MinNumberLength) { 50 memset(&NumBuffer[Pos], 0, 51 sizeof(NumBuffer[0]) * static_cast<uptr>(MinNumberLength - Pos)); 52 Pos = MinNumberLength; 53 } 54 RAW_CHECK(Pos > 0); 55 Pos--; 56 for (; Pos >= 0 && NumBuffer[Pos] == 0; Pos--) { 57 char c = (PadWithZero || Pos == 0) ? '0' : ' '; 58 Res += appendChar(Buffer, BufferEnd, c); 59 } 60 if (Negative && !PadWithZero) 61 Res += appendChar(Buffer, BufferEnd, '-'); 62 for (; Pos >= 0; Pos--) { 63 char Digit = static_cast<char>(NumBuffer[Pos]); 64 Digit = static_cast<char>((Digit < 10) ? '0' + Digit 65 : (Upper ? 'A' : 'a') + Digit - 10); 66 Res += appendChar(Buffer, BufferEnd, Digit); 67 } 68 return Res; 69 } 70 71 static int appendUnsigned(char **Buffer, const char *BufferEnd, u64 Num, 72 u8 Base, u8 MinNumberLength, bool PadWithZero, 73 bool Upper) { 74 return appendNumber(Buffer, BufferEnd, Num, Base, MinNumberLength, 75 PadWithZero, /*Negative=*/false, Upper); 76 } 77 78 static int appendSignedDecimal(char **Buffer, const char *BufferEnd, s64 Num, 79 u8 MinNumberLength, bool PadWithZero) { 80 const bool Negative = (Num < 0); 81 return appendNumber(Buffer, BufferEnd, 82 static_cast<u64>(Negative ? -Num : Num), 10, 83 MinNumberLength, PadWithZero, Negative, 84 /*Upper=*/false); 85 } 86 87 // Use the fact that explicitly requesting 0 Width (%0s) results in UB and 88 // interpret Width == 0 as "no Width requested": 89 // Width == 0 - no Width requested 90 // Width < 0 - left-justify S within and pad it to -Width chars, if necessary 91 // Width > 0 - right-justify S, not implemented yet 92 static int appendString(char **Buffer, const char *BufferEnd, int Width, 93 int MaxChars, const char *S) { 94 if (!S) 95 S = "<null>"; 96 int Res = 0; 97 for (; *S; S++) { 98 if (MaxChars >= 0 && Res >= MaxChars) 99 break; 100 Res += appendChar(Buffer, BufferEnd, *S); 101 } 102 // Only the left justified strings are supported. 103 while (Width < -Res) 104 Res += appendChar(Buffer, BufferEnd, ' '); 105 return Res; 106 } 107 108 static int appendPointer(char **Buffer, const char *BufferEnd, u64 ptr_value) { 109 int Res = 0; 110 Res += appendString(Buffer, BufferEnd, 0, -1, "0x"); 111 Res += appendUnsigned(Buffer, BufferEnd, ptr_value, 16, 112 SCUDO_POINTER_FORMAT_LENGTH, /*PadWithZero=*/true, 113 /*Upper=*/false); 114 return Res; 115 } 116 117 int formatString(char *Buffer, uptr BufferLength, const char *Format, 118 va_list Args) { 119 static const char *PrintfFormatsHelp = 120 "Supported formatString formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; " 121 "%[-]([0-9]*)?(\\.\\*)?s; %c\n"; 122 RAW_CHECK(Format); 123 RAW_CHECK(BufferLength > 0); 124 const char *BufferEnd = &Buffer[BufferLength - 1]; 125 const char *Cur = Format; 126 int Res = 0; 127 for (; *Cur; Cur++) { 128 if (*Cur != '%') { 129 Res += appendChar(&Buffer, BufferEnd, *Cur); 130 continue; 131 } 132 Cur++; 133 const bool LeftJustified = *Cur == '-'; 134 if (LeftJustified) 135 Cur++; 136 bool HaveWidth = (*Cur >= '0' && *Cur <= '9'); 137 const bool PadWithZero = (*Cur == '0'); 138 u8 Width = 0; 139 if (HaveWidth) { 140 while (*Cur >= '0' && *Cur <= '9') 141 Width = static_cast<u8>(Width * 10 + *Cur++ - '0'); 142 } 143 const bool HavePrecision = (Cur[0] == '.' && Cur[1] == '*'); 144 int Precision = -1; 145 if (HavePrecision) { 146 Cur += 2; 147 Precision = va_arg(Args, int); 148 } 149 const bool HaveZ = (*Cur == 'z'); 150 Cur += HaveZ; 151 const bool HaveLL = !HaveZ && (Cur[0] == 'l' && Cur[1] == 'l'); 152 Cur += HaveLL * 2; 153 s64 DVal; 154 u64 UVal; 155 const bool HaveLength = HaveZ || HaveLL; 156 const bool HaveFlags = HaveWidth || HaveLength; 157 // At the moment only %s supports precision and left-justification. 158 CHECK(!((Precision >= 0 || LeftJustified) && *Cur != 's')); 159 switch (*Cur) { 160 case 'd': { 161 DVal = HaveLL ? va_arg(Args, s64) 162 : HaveZ ? va_arg(Args, sptr) : va_arg(Args, int); 163 Res += appendSignedDecimal(&Buffer, BufferEnd, DVal, Width, PadWithZero); 164 break; 165 } 166 case 'u': 167 case 'x': 168 case 'X': { 169 UVal = HaveLL ? va_arg(Args, u64) 170 : HaveZ ? va_arg(Args, uptr) : va_arg(Args, unsigned); 171 const bool Upper = (*Cur == 'X'); 172 Res += appendUnsigned(&Buffer, BufferEnd, UVal, (*Cur == 'u') ? 10 : 16, 173 Width, PadWithZero, Upper); 174 break; 175 } 176 case 'p': { 177 RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp); 178 Res += appendPointer(&Buffer, BufferEnd, va_arg(Args, uptr)); 179 break; 180 } 181 case 's': { 182 RAW_CHECK_MSG(!HaveLength, PrintfFormatsHelp); 183 // Only left-justified Width is supported. 184 CHECK(!HaveWidth || LeftJustified); 185 Res += appendString(&Buffer, BufferEnd, LeftJustified ? -Width : Width, 186 Precision, va_arg(Args, char *)); 187 break; 188 } 189 case 'c': { 190 RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp); 191 Res += 192 appendChar(&Buffer, BufferEnd, static_cast<char>(va_arg(Args, int))); 193 break; 194 } 195 case '%': { 196 RAW_CHECK_MSG(!HaveFlags, PrintfFormatsHelp); 197 Res += appendChar(&Buffer, BufferEnd, '%'); 198 break; 199 } 200 default: { 201 RAW_CHECK_MSG(false, PrintfFormatsHelp); 202 } 203 } 204 } 205 RAW_CHECK(Buffer <= BufferEnd); 206 appendChar(&Buffer, BufferEnd + 1, '\0'); 207 return Res; 208 } 209 210 void ScopedString::append(const char *Format, va_list Args) { 211 DCHECK_LT(Length, String.size()); 212 va_list ArgsCopy; 213 va_copy(ArgsCopy, Args); 214 // formatString doesn't currently support a null buffer or zero buffer length, 215 // so in order to get the resulting formatted string length, we use a one-char 216 // buffer. 217 char C[1]; 218 const uptr AdditionalLength = 219 static_cast<uptr>(formatString(C, sizeof(C), Format, Args)) + 1; 220 String.resize(Length + AdditionalLength); 221 formatString(String.data() + Length, AdditionalLength, Format, ArgsCopy); 222 Length = strlen(String.data()); 223 CHECK_LT(Length, String.size()); 224 } 225 226 FORMAT(2, 3) 227 void ScopedString::append(const char *Format, ...) { 228 va_list Args; 229 va_start(Args, Format); 230 append(Format, Args); 231 va_end(Args); 232 } 233 234 FORMAT(1, 2) 235 void Printf(const char *Format, ...) { 236 va_list Args; 237 va_start(Args, Format); 238 ScopedString Msg(1024); 239 Msg.append(Format, Args); 240 outputRaw(Msg.data()); 241 va_end(Args); 242 } 243 244 } // namespace scudo 245