1 //===-- sanitizer_printf.cc -----------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is shared between AddressSanitizer and ThreadSanitizer.
10 // Internal printf function, used inside run-time libraries.
11 // We can't use libc printf because we intercept some of the functions used
13 //===----------------------------------------------------------------------===//
15 #include "sanitizer_common.h"
16 #include "sanitizer_flags.h"
17 #include "sanitizer_libc.h"
22 #if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 && \
24 # define va_copy(dst, src) ((dst) = (src))
27 namespace __sanitizer
{
29 static int AppendChar(char **buff
, const char *buff_end
, char c
) {
30 if (*buff
< buff_end
) {
37 // Appends number in a given base to buffer. If its length is less than
38 // |minimal_num_length|, it is padded with leading zeroes or spaces, depending
39 // on the value of |pad_with_zero|.
40 static int AppendNumber(char **buff
, const char *buff_end
, u64 absolute_value
,
41 u8 base
, u8 minimal_num_length
, bool pad_with_zero
,
42 bool negative
, bool uppercase
) {
43 uptr
const kMaxLen
= 30;
44 RAW_CHECK(base
== 10 || base
== 16);
45 RAW_CHECK(base
== 10 || !negative
);
46 RAW_CHECK(absolute_value
|| !negative
);
47 RAW_CHECK(minimal_num_length
< kMaxLen
);
49 if (negative
&& minimal_num_length
)
51 if (negative
&& pad_with_zero
)
52 result
+= AppendChar(buff
, buff_end
, '-');
53 uptr num_buffer
[kMaxLen
];
56 RAW_CHECK_MSG((uptr
)pos
< kMaxLen
, "AppendNumber buffer overflow");
57 num_buffer
[pos
++] = absolute_value
% base
;
58 absolute_value
/= base
;
59 } while (absolute_value
> 0);
60 if (pos
< minimal_num_length
) {
61 // Make sure compiler doesn't insert call to memset here.
62 internal_memset(&num_buffer
[pos
], 0,
63 sizeof(num_buffer
[0]) * (minimal_num_length
- pos
));
64 pos
= minimal_num_length
;
68 for (; pos
>= 0 && num_buffer
[pos
] == 0; pos
--) {
69 char c
= (pad_with_zero
|| pos
== 0) ? '0' : ' ';
70 result
+= AppendChar(buff
, buff_end
, c
);
72 if (negative
&& !pad_with_zero
) result
+= AppendChar(buff
, buff_end
, '-');
73 for (; pos
>= 0; pos
--) {
74 char digit
= static_cast<char>(num_buffer
[pos
]);
75 digit
= (digit
< 10) ? '0' + digit
: (uppercase
? 'A' : 'a') + digit
- 10;
76 result
+= AppendChar(buff
, buff_end
, digit
);
81 static int AppendUnsigned(char **buff
, const char *buff_end
, u64 num
, u8 base
,
82 u8 minimal_num_length
, bool pad_with_zero
,
84 return AppendNumber(buff
, buff_end
, num
, base
, minimal_num_length
,
85 pad_with_zero
, false /* negative */, uppercase
);
88 static int AppendSignedDecimal(char **buff
, const char *buff_end
, s64 num
,
89 u8 minimal_num_length
, bool pad_with_zero
) {
90 bool negative
= (num
< 0);
91 return AppendNumber(buff
, buff_end
, (u64
)(negative
? -num
: num
), 10,
92 minimal_num_length
, pad_with_zero
, negative
,
93 false /* uppercase */);
97 // Use the fact that explicitly requesting 0 width (%0s) results in UB and
98 // interpret width == 0 as "no width requested":
99 // width == 0 - no width requested
100 // width < 0 - left-justify s within and pad it to -width chars, if necessary
101 // width > 0 - right-justify s, not implemented yet
102 static int AppendString(char **buff
, const char *buff_end
, int width
,
103 int max_chars
, const char *s
) {
108 if (max_chars
>= 0 && result
>= max_chars
)
110 result
+= AppendChar(buff
, buff_end
, *s
);
112 // Only the left justified strings are supported.
113 while (width
< -result
)
114 result
+= AppendChar(buff
, buff_end
, ' ');
118 static int AppendPointer(char **buff
, const char *buff_end
, u64 ptr_value
) {
120 result
+= AppendString(buff
, buff_end
, 0, -1, "0x");
121 result
+= AppendUnsigned(buff
, buff_end
, ptr_value
, 16,
122 SANITIZER_POINTER_FORMAT_LENGTH
,
123 true /* pad_with_zero */, false /* uppercase */);
127 int VSNPrintf(char *buff
, int buff_length
,
128 const char *format
, va_list args
) {
129 static const char *kPrintfFormatsHelp
=
130 "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
131 "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
133 RAW_CHECK(buff_length
> 0);
134 const char *buff_end
= &buff
[buff_length
- 1];
135 const char *cur
= format
;
137 for (; *cur
; cur
++) {
139 result
+= AppendChar(&buff
, buff_end
, *cur
);
143 bool left_justified
= *cur
== '-';
146 bool have_width
= (*cur
>= '0' && *cur
<= '9');
147 bool pad_with_zero
= (*cur
== '0');
150 while (*cur
>= '0' && *cur
<= '9') {
151 width
= width
* 10 + *cur
++ - '0';
154 bool have_precision
= (cur
[0] == '.' && cur
[1] == '*');
156 if (have_precision
) {
158 precision
= va_arg(args
, int);
160 bool have_z
= (*cur
== 'z');
162 bool have_ll
= !have_z
&& (cur
[0] == 'l' && cur
[1] == 'l');
166 const bool have_length
= have_z
|| have_ll
;
167 const bool have_flags
= have_width
|| have_length
;
168 // At the moment only %s supports precision and left-justification.
169 CHECK(!((precision
>= 0 || left_justified
) && *cur
!= 's'));
172 dval
= have_ll
? va_arg(args
, s64
)
173 : have_z
? va_arg(args
, sptr
)
175 result
+= AppendSignedDecimal(&buff
, buff_end
, dval
, width
,
182 uval
= have_ll
? va_arg(args
, u64
)
183 : have_z
? va_arg(args
, uptr
)
184 : va_arg(args
, unsigned);
185 bool uppercase
= (*cur
== 'X');
186 result
+= AppendUnsigned(&buff
, buff_end
, uval
, (*cur
== 'u') ? 10 : 16,
187 width
, pad_with_zero
, uppercase
);
191 RAW_CHECK_MSG(!have_flags
, kPrintfFormatsHelp
);
192 result
+= AppendPointer(&buff
, buff_end
, va_arg(args
, uptr
));
196 RAW_CHECK_MSG(!have_length
, kPrintfFormatsHelp
);
197 // Only left-justified width is supported.
198 CHECK(!have_width
|| left_justified
);
199 result
+= AppendString(&buff
, buff_end
, left_justified
? -width
: width
,
200 precision
, va_arg(args
, char*));
204 RAW_CHECK_MSG(!have_flags
, kPrintfFormatsHelp
);
205 result
+= AppendChar(&buff
, buff_end
, va_arg(args
, int));
209 RAW_CHECK_MSG(!have_flags
, kPrintfFormatsHelp
);
210 result
+= AppendChar(&buff
, buff_end
, '%');
214 RAW_CHECK_MSG(false, kPrintfFormatsHelp
);
218 RAW_CHECK(buff
<= buff_end
);
219 AppendChar(&buff
, buff_end
+ 1, '\0');
223 static void (*PrintfAndReportCallback
)(const char *);
224 void SetPrintfAndReportCallback(void (*callback
)(const char *)) {
225 PrintfAndReportCallback
= callback
;
228 // Can be overriden in frontend.
229 #if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)
230 // Implementation must be defined in frontend.
231 extern "C" void OnPrint(const char *str
);
233 SANITIZER_INTERFACE_WEAK_DEF(void, OnPrint
, const char *str
) {
238 static void CallPrintfAndReportCallback(const char *str
) {
240 if (PrintfAndReportCallback
)
241 PrintfAndReportCallback(str
);
244 static void NOINLINE
SharedPrintfCodeNoBuffer(bool append_pid
,
250 va_copy(args2
, args
);
251 const int kLen
= 16 * 1024;
253 char *buffer
= local_buffer
;
254 // First try to print a message using a local buffer, and then fall back to
256 for (int use_mmap
= 0; use_mmap
< 2; use_mmap
++) {
259 va_copy(args
, args2
);
260 buffer
= (char*)MmapOrDie(kLen
, "Report");
264 // Check that data fits into the current buffer.
265 # define CHECK_NEEDED_LENGTH \
266 if (needed_length >= buffer_size) { \
267 if (!use_mmap) continue; \
268 RAW_CHECK_MSG(needed_length < kLen, \
269 "Buffer in Report is too short!\n"); \
271 // Fuchsia's logging infrastructure always keeps track of the logging
272 // process, thread, and timestamp, so never prepend such information.
273 if (!SANITIZER_FUCHSIA
&& append_pid
) {
274 int pid
= internal_getpid();
275 const char *exe_name
= GetProcessName();
276 if (common_flags()->log_exe_name
&& exe_name
) {
277 needed_length
+= internal_snprintf(buffer
, buffer_size
,
281 needed_length
+= internal_snprintf(
282 buffer
+ needed_length
, buffer_size
- needed_length
, "==%d==", pid
);
285 needed_length
+= VSNPrintf(buffer
+ needed_length
,
286 buffer_size
- needed_length
, format
, args
);
288 // If the message fit into the buffer, print it and exit.
290 # undef CHECK_NEEDED_LENGTH
294 // Remove color sequences from the message.
295 RemoveANSIEscapeSequencesFromString(buffer
);
296 CallPrintfAndReportCallback(buffer
);
297 LogMessageOnPrintf(buffer
);
299 // If we had mapped any memory, clean up.
300 if (buffer
!= local_buffer
)
301 UnmapOrDie((void *)buffer
, buffer_size
);
305 static void NOINLINE
SharedPrintfCode(bool append_pid
, const char *format
,
307 // |local_buffer| is small enough not to overflow the stack and/or violate
308 // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
309 // hand, the bigger the buffer is, the more the chance the error report will
311 char local_buffer
[400];
312 SharedPrintfCodeNoBuffer(append_pid
, local_buffer
, ARRAY_SIZE(local_buffer
),
317 void Printf(const char *format
, ...) {
319 va_start(args
, format
);
320 SharedPrintfCode(false, format
, args
);
324 // Like Printf, but prints the current PID before the output string.
326 void Report(const char *format
, ...) {
328 va_start(args
, format
);
329 SharedPrintfCode(true, format
, args
);
333 // Writes at most "length" symbols to "buffer" (including trailing '\0').
334 // Returns the number of symbols that should have been written to buffer
335 // (not including trailing '\0'). Thus, the string is truncated
336 // iff return value is not less than "length".
338 int internal_snprintf(char *buffer
, uptr length
, const char *format
, ...) {
340 va_start(args
, format
);
341 int needed_length
= VSNPrintf(buffer
, length
, format
, args
);
343 return needed_length
;
347 void InternalScopedString::append(const char *format
, ...) {
348 CHECK_LT(length_
, size());
350 va_start(args
, format
);
351 VSNPrintf(data() + length_
, size() - length_
, format
, args
);
353 length_
+= internal_strlen(data() + length_
);
354 CHECK_LT(length_
, size());
357 } // namespace __sanitizer