1 //===-- sanitizer_printf.cc -----------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is shared between AddressSanitizer and ThreadSanitizer.
12 // Internal printf function, used inside run-time libraries.
13 // We can't use libc printf because we intercept some of the functions used
15 //===----------------------------------------------------------------------===//
17 #include "sanitizer_common.h"
18 #include "sanitizer_flags.h"
19 #include "sanitizer_libc.h"
24 #if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 && \
26 # define va_copy(dst, src) ((dst) = (src))
29 namespace __sanitizer {
31 StaticSpinMutex CommonSanitizerReportMutex;
33 static int AppendChar(char **buff, const char *buff_end, char c) {
34 if (*buff < buff_end) {
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,
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);
53 if (negative && minimal_num_length)
55 if (negative && pad_with_zero)
56 result += AppendChar(buff, buff_end, '-');
57 uptr num_buffer[kMaxLen];
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;
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);
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 result += AppendChar(buff, buff_end, (digit < 10) ? '0' + digit
85 static int AppendUnsigned(char **buff, const char *buff_end, u64 num, u8 base,
86 u8 minimal_num_length, bool pad_with_zero) {
87 return AppendNumber(buff, buff_end, num, base, minimal_num_length,
88 pad_with_zero, false /* negative */);
91 static int AppendSignedDecimal(char **buff, const char *buff_end, s64 num,
92 u8 minimal_num_length, bool pad_with_zero) {
93 bool negative = (num < 0);
94 return AppendNumber(buff, buff_end, (u64)(negative ? -num : num), 10,
95 minimal_num_length, pad_with_zero, negative);
98 static int AppendString(char **buff, const char *buff_end, int precision,
104 if (precision >= 0 && result >= precision)
106 result += AppendChar(buff, buff_end, *s);
111 static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
113 result += AppendString(buff, buff_end, -1, "0x");
114 result += AppendUnsigned(buff, buff_end, ptr_value, 16,
115 SANITIZER_POINTER_FORMAT_LENGTH, true);
119 int VSNPrintf(char *buff, int buff_length,
120 const char *format, va_list args) {
121 static const char *kPrintfFormatsHelp =
122 "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x}; %p; %(\\.\\*)?s; %c\n";
124 RAW_CHECK(buff_length > 0);
125 const char *buff_end = &buff[buff_length - 1];
126 const char *cur = format;
128 for (; *cur; cur++) {
130 result += AppendChar(&buff, buff_end, *cur);
134 bool have_width = (*cur >= '0' && *cur <= '9');
135 bool pad_with_zero = (*cur == '0');
138 while (*cur >= '0' && *cur <= '9') {
139 width = width * 10 + *cur++ - '0';
142 bool have_precision = (cur[0] == '.' && cur[1] == '*');
144 if (have_precision) {
146 precision = va_arg(args, int);
148 bool have_z = (*cur == 'z');
150 bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
154 bool have_flags = have_width | have_z | have_ll;
155 // Only %s supports precision for now
156 CHECK(!(precision >= 0 && *cur != 's'));
159 dval = have_ll ? va_arg(args, s64)
160 : have_z ? va_arg(args, sptr)
162 result += AppendSignedDecimal(&buff, buff_end, dval, width,
168 uval = have_ll ? va_arg(args, u64)
169 : have_z ? va_arg(args, uptr)
170 : va_arg(args, unsigned);
171 result += AppendUnsigned(&buff, buff_end, uval,
172 (*cur == 'u') ? 10 : 16, width, pad_with_zero);
176 RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
177 result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
181 RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
182 result += AppendString(&buff, buff_end, precision, va_arg(args, char*));
186 RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
187 result += AppendChar(&buff, buff_end, va_arg(args, int));
191 RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
192 result += AppendChar(&buff, buff_end, '%');
196 RAW_CHECK_MSG(false, kPrintfFormatsHelp);
200 RAW_CHECK(buff <= buff_end);
201 AppendChar(&buff, buff_end + 1, '\0');
205 static void (*PrintfAndReportCallback)(const char *);
206 void SetPrintfAndReportCallback(void (*callback)(const char *)) {
207 PrintfAndReportCallback = callback;
210 // Can be overriden in frontend.
211 #if SANITIZER_SUPPORTS_WEAK_HOOKS
212 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
213 void OnPrint(const char *str) {
216 #elif defined(SANITIZER_GO) && defined(TSAN_EXTERNAL_HOOKS)
217 void OnPrint(const char *str);
219 void OnPrint(const char *str) {
224 static void CallPrintfAndReportCallback(const char *str) {
226 if (PrintfAndReportCallback)
227 PrintfAndReportCallback(str);
230 static void SharedPrintfCode(bool append_pid, const char *format,
233 va_copy(args2, args);
234 const int kLen = 16 * 1024;
235 // |local_buffer| is small enough not to overflow the stack and/or violate
236 // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
237 // hand, the bigger the buffer is, the more the chance the error report will
239 char local_buffer[400];
241 char *buffer = local_buffer;
242 int buffer_size = ARRAY_SIZE(local_buffer);
243 // First try to print a message using a local buffer, and then fall back to
245 for (int use_mmap = 0; use_mmap < 2; use_mmap++) {
248 va_copy(args, args2);
249 buffer = (char*)MmapOrDie(kLen, "Report");
253 // Check that data fits into the current buffer.
254 # define CHECK_NEEDED_LENGTH \
255 if (needed_length >= buffer_size) { \
256 if (!use_mmap) continue; \
257 RAW_CHECK_MSG(needed_length < kLen, \
258 "Buffer in Report is too short!\n"); \
261 int pid = internal_getpid();
262 const char *exe_name = GetProcessName();
263 if (common_flags()->log_exe_name && exe_name) {
264 needed_length += internal_snprintf(buffer, buffer_size,
268 needed_length += internal_snprintf(buffer + needed_length,
269 buffer_size - needed_length,
273 needed_length += VSNPrintf(buffer + needed_length,
274 buffer_size - needed_length, format, args);
276 // If the message fit into the buffer, print it and exit.
278 # undef CHECK_NEEDED_LENGTH
282 // Remove color sequences from the message.
283 RemoveANSIEscapeSequencesFromString(buffer);
284 CallPrintfAndReportCallback(buffer);
285 LogMessageOnPrintf(buffer);
287 // If we had mapped any memory, clean up.
288 if (buffer != local_buffer)
289 UnmapOrDie((void *)buffer, buffer_size);
294 void Printf(const char *format, ...) {
296 va_start(args, format);
297 SharedPrintfCode(false, format, args);
301 // Like Printf, but prints the current PID before the output string.
303 void Report(const char *format, ...) {
305 va_start(args, format);
306 SharedPrintfCode(true, format, args);
310 // Writes at most "length" symbols to "buffer" (including trailing '\0').
311 // Returns the number of symbols that should have been written to buffer
312 // (not including trailing '\0'). Thus, the string is truncated
313 // iff return value is not less than "length".
315 int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
317 va_start(args, format);
318 int needed_length = VSNPrintf(buffer, length, format, args);
320 return needed_length;
324 void InternalScopedString::append(const char *format, ...) {
325 CHECK_LT(length_, size());
327 va_start(args, format);
328 VSNPrintf(data() + length_, size() - length_, format, args);
330 length_ += internal_strlen(data() + length_);
331 CHECK_LT(length_, size());
334 } // namespace __sanitizer