contrib/compiler-rt/lib/sanitizer_common/sanitizer_printf.cc

   1 //===-- sanitizer_printf.cc -----------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between AddressSanitizer and ThreadSanitizer.
  11 //
  12 // Internal printf function, used inside run-time libraries.
  13 // We can't use libc printf because we intercept some of the functions used
  14 // inside it.
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "sanitizer_common.h"
  18 #include "sanitizer_flags.h"
  19 #include "sanitizer_libc.h"
  20
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23
  24 #if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 &&               \
  25       !defined(va_copy)
  26 # define va_copy(dst, src) ((dst) = (src))
  27 #endif
  28
  29 namespace __sanitizer {
  30
  31 StaticSpinMutex CommonSanitizerReportMutex;
  32
  33 static int AppendChar(char **buff, const char *buff_end, char c) {
  34   if (*buff < buff_end) {
  35     **buff = c;
  36     (*buff)++;
  37   }
  38   return 1;
  39 }
  40
  41 // Appends number in a given base to buffer. If its length is less than
  42 // |minimal_num_length|, it is padded with leading zeroes or spaces, depending
  43 // on the value of |pad_with_zero|.
  44 static int AppendNumber(char **buff, const char *buff_end, u64 absolute_value,
  45                         u8 base, u8 minimal_num_length, bool pad_with_zero,
  46                         bool negative, bool uppercase) {
  47   uptr const kMaxLen = 30;
  48   RAW_CHECK(base == 10 || base == 16);
  49   RAW_CHECK(base == 10 || !negative);
  50   RAW_CHECK(absolute_value || !negative);
  51   RAW_CHECK(minimal_num_length < kMaxLen);
  52   int result = 0;
  53   if (negative && minimal_num_length)
  54     --minimal_num_length;
  55   if (negative && pad_with_zero)
  56     result += AppendChar(buff, buff_end, '-');
  57   uptr num_buffer[kMaxLen];
  58   int pos = 0;
  59   do {
  60     RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow");
  61     num_buffer[pos++] = absolute_value % base;
  62     absolute_value /= base;
  63   } while (absolute_value > 0);
  64   if (pos < minimal_num_length) {
  65     // Make sure compiler doesn't insert call to memset here.
  66     internal_memset(&num_buffer[pos], 0,
  67                     sizeof(num_buffer[0]) * (minimal_num_length - pos));
  68     pos = minimal_num_length;
  69   }
  70   RAW_CHECK(pos > 0);
  71   pos--;
  72   for (; pos >= 0 && num_buffer[pos] == 0; pos--) {
  73     char c = (pad_with_zero || pos == 0) ? '0' : ' ';
  74     result += AppendChar(buff, buff_end, c);
  75   }
  76   if (negative && !pad_with_zero) result += AppendChar(buff, buff_end, '-');
  77   for (; pos >= 0; pos--) {
  78     char digit = static_cast<char>(num_buffer[pos]);
  79     digit = (digit < 10) ? '0' + digit : (uppercase ? 'A' : 'a') + digit - 10;
  80     result += AppendChar(buff, buff_end, digit);
  81   }
  82   return result;
  83 }
  84
  85 static int AppendUnsigned(char **buff, const char *buff_end, u64 num, u8 base,
  86                           u8 minimal_num_length, bool pad_with_zero,
  87                           bool uppercase) {
  88   return AppendNumber(buff, buff_end, num, base, minimal_num_length,
  89                       pad_with_zero, false /* negative */, uppercase);
  90 }
  91
  92 static int AppendSignedDecimal(char **buff, const char *buff_end, s64 num,
  93                                u8 minimal_num_length, bool pad_with_zero) {
  94   bool negative = (num < 0);
  95   return AppendNumber(buff, buff_end, (u64)(negative ? -num : num), 10,
  96                       minimal_num_length, pad_with_zero, negative,
  97                       false /* uppercase */);
  98 }
  99
 100 static int AppendString(char **buff, const char *buff_end, int precision,
 101                         const char *s) {
 102   if (!s)
 103     s = "<null>";
 104   int result = 0;
 105   for (; *s; s++) {
 106     if (precision >= 0 && result >= precision)
 107       break;
 108     result += AppendChar(buff, buff_end, *s);
 109   }
 110   return result;
 111 }
 112
 113 static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
 114   int result = 0;
 115   result += AppendString(buff, buff_end, -1, "0x");
 116   result += AppendUnsigned(buff, buff_end, ptr_value, 16,
 117                            SANITIZER_POINTER_FORMAT_LENGTH,
 118                            true /* pad_with_zero */, false /* uppercase */);
 119   return result;
 120 }
 121
 122 int VSNPrintf(char *buff, int buff_length,
 123               const char *format, va_list args) {
 124   static const char *kPrintfFormatsHelp =
 125       "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; %(\\.\\*)?s; "
 126       "%c\n";
 127   RAW_CHECK(format);
 128   RAW_CHECK(buff_length > 0);
 129   const char *buff_end = &buff[buff_length - 1];
 130   const char *cur = format;
 131   int result = 0;
 132   for (; *cur; cur++) {
 133     if (*cur != '%') {
 134       result += AppendChar(&buff, buff_end, *cur);
 135       continue;
 136     }
 137     cur++;
 138     bool have_width = (*cur >= '0' && *cur <= '9');
 139     bool pad_with_zero = (*cur == '0');
 140     int width = 0;
 141     if (have_width) {
 142       while (*cur >= '0' && *cur <= '9') {
 143         width = width * 10 + *cur++ - '0';
 144       }
 145     }
 146     bool have_precision = (cur[0] == '.' && cur[1] == '*');
 147     int precision = -1;
 148     if (have_precision) {
 149       cur += 2;
 150       precision = va_arg(args, int);
 151     }
 152     bool have_z = (*cur == 'z');
 153     cur += have_z;
 154     bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
 155     cur += have_ll * 2;
 156     s64 dval;
 157     u64 uval;
 158     bool have_flags = have_width | have_z | have_ll;
 159     // Only %s supports precision for now
 160     CHECK(!(precision >= 0 && *cur != 's'));
 161     switch (*cur) {
 162       case 'd': {
 163         dval = have_ll ? va_arg(args, s64)
 164              : have_z ? va_arg(args, sptr)
 165              : va_arg(args, int);
 166         result += AppendSignedDecimal(&buff, buff_end, dval, width,
 167                                       pad_with_zero);
 168         break;
 169       }
 170       case 'u':
 171       case 'x':
 172       case 'X': {
 173         uval = have_ll ? va_arg(args, u64)
 174              : have_z ? va_arg(args, uptr)
 175              : va_arg(args, unsigned);
 176         bool uppercase = (*cur == 'X');
 177         result += AppendUnsigned(&buff, buff_end, uval, (*cur == 'u') ? 10 : 16,
 178                                  width, pad_with_zero, uppercase);
 179         break;
 180       }
 181       case 'p': {
 182         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
 183         result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
 184         break;
 185       }
 186       case 's': {
 187         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
 188         result += AppendString(&buff, buff_end, precision, va_arg(args, char*));
 189         break;
 190       }
 191       case 'c': {
 192         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
 193         result += AppendChar(&buff, buff_end, va_arg(args, int));
 194         break;
 195       }
 196       case '%' : {
 197         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
 198         result += AppendChar(&buff, buff_end, '%');
 199         break;
 200       }
 201       default: {
 202         RAW_CHECK_MSG(false, kPrintfFormatsHelp);
 203       }
 204     }
 205   }
 206   RAW_CHECK(buff <= buff_end);
 207   AppendChar(&buff, buff_end + 1, '\0');
 208   return result;
 209 }
 210
 211 static void (*PrintfAndReportCallback)(const char *);
 212 void SetPrintfAndReportCallback(void (*callback)(const char *)) {
 213   PrintfAndReportCallback = callback;
 214 }
 215
 216 // Can be overriden in frontend.
 217 #if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)
 218 // Implementation must be defined in frontend.
 219 extern "C" void OnPrint(const char *str);
 220 #else
 221 SANITIZER_INTERFACE_WEAK_DEF(void, OnPrint, const char *str) {
 222   (void)str;
 223 }
 224 #endif
 225
 226 static void CallPrintfAndReportCallback(const char *str) {
 227   OnPrint(str);
 228   if (PrintfAndReportCallback)
 229     PrintfAndReportCallback(str);
 230 }
 231
 232 static void SharedPrintfCode(bool append_pid, const char *format,
 233                              va_list args) {
 234   va_list args2;
 235   va_copy(args2, args);
 236   const int kLen = 16 * 1024;
 237   // |local_buffer| is small enough not to overflow the stack and/or violate
 238   // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
 239   // hand, the bigger the buffer is, the more the chance the error report will
 240   // fit into it.
 241   char local_buffer[400];
 242   int needed_length;
 243   char *buffer = local_buffer;
 244   int buffer_size = ARRAY_SIZE(local_buffer);
 245   // First try to print a message using a local buffer, and then fall back to
 246   // mmaped buffer.
 247   for (int use_mmap = 0; use_mmap < 2; use_mmap++) {
 248     if (use_mmap) {
 249       va_end(args);
 250       va_copy(args, args2);
 251       buffer = (char*)MmapOrDie(kLen, "Report");
 252       buffer_size = kLen;
 253     }
 254     needed_length = 0;
 255     // Check that data fits into the current buffer.
 256 #   define CHECK_NEEDED_LENGTH \
 257       if (needed_length >= buffer_size) { \
 258         if (!use_mmap) continue; \
 259         RAW_CHECK_MSG(needed_length < kLen, \
 260                       "Buffer in Report is too short!\n"); \
 261       }
 262     if (append_pid) {
 263       int pid = internal_getpid();
 264       const char *exe_name = GetProcessName();
 265       if (common_flags()->log_exe_name && exe_name) {
 266         needed_length += internal_snprintf(buffer, buffer_size,
 267                                            "==%s", exe_name);
 268         CHECK_NEEDED_LENGTH
 269       }
 270       needed_length += internal_snprintf(buffer + needed_length,
 271                                          buffer_size - needed_length,
 272                                          "==%d==", pid);
 273       CHECK_NEEDED_LENGTH
 274     }
 275     needed_length += VSNPrintf(buffer + needed_length,
 276                                buffer_size - needed_length, format, args);
 277     CHECK_NEEDED_LENGTH
 278     // If the message fit into the buffer, print it and exit.
 279     break;
 280 #   undef CHECK_NEEDED_LENGTH
 281   }
 282   RawWrite(buffer);
 283
 284   // Remove color sequences from the message.
 285   RemoveANSIEscapeSequencesFromString(buffer);
 286   CallPrintfAndReportCallback(buffer);
 287   LogMessageOnPrintf(buffer);
 288
 289   // If we had mapped any memory, clean up.
 290   if (buffer != local_buffer)
 291     UnmapOrDie((void *)buffer, buffer_size);
 292   va_end(args2);
 293 }
 294
 295 FORMAT(1, 2)
 296 void Printf(const char *format, ...) {
 297   va_list args;
 298   va_start(args, format);
 299   SharedPrintfCode(false, format, args);
 300   va_end(args);
 301 }
 302
 303 // Like Printf, but prints the current PID before the output string.
 304 FORMAT(1, 2)
 305 void Report(const char *format, ...) {
 306   va_list args;
 307   va_start(args, format);
 308   SharedPrintfCode(true, format, args);
 309   va_end(args);
 310 }
 311
 312 // Writes at most "length" symbols to "buffer" (including trailing '\0').
 313 // Returns the number of symbols that should have been written to buffer
 314 // (not including trailing '\0'). Thus, the string is truncated
 315 // iff return value is not less than "length".
 316 FORMAT(3, 4)
 317 int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
 318   va_list args;
 319   va_start(args, format);
 320   int needed_length = VSNPrintf(buffer, length, format, args);
 321   va_end(args);
 322   return needed_length;
 323 }
 324
 325 FORMAT(2, 3)
 326 void InternalScopedString::append(const char *format, ...) {
 327   CHECK_LT(length_, size());
 328   va_list args;
 329   va_start(args, format);
 330   VSNPrintf(data() + length_, size() - length_, format, args);
 331   va_end(args);
 332   length_ += internal_strlen(data() + length_);
 333   CHECK_LT(length_, size());
 334 }
 335
 336 } // namespace __sanitizer