1
2 /*--------------------------------------------------------------------*/
3 /*--- Debug (not-for-user) logging; also vprintf. m_debuglog.c ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2000-2010 Julian Seward
11 jseward@acm.org
12
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 02111-1307, USA.
27
28 The GNU General Public License is contained in the file COPYING.
29 */
30
31
32 /* Performs low-level debug logging that can safely run immediately
33 after startup. To minimise the dependencies on any other parts of
34 the system, the only place the debug output may go is file
35 descriptor 2 (stderr).
36 */
37 /* This is the first-initialised module in the entire system!
38 Therefore it is CRITICAL that it does not depend on any other code
39 running first. Hence only the following very limited includes. We
40 cannot depend (directly or indirectly) on any dynamic memory
41 allocation facilities, nor on the m_libc facilities, since the
42 latter depend on this module. DO NOT MESS WITH THESE INCLUDES
43 UNLESS YOU ARE 100% CERTAIN YOU UNDERSTAND THE CONSEQUENCES.
44 */
45
46 /* This module is also notable because it is linked into both
47 stage1 and stage2. */
48
49 /* IMPORTANT: on Darwin it is essential to use the _nocancel versions
50 of syscalls rather than the vanilla version, if a _nocancel version
51 is available. See docs/internals/Darwin-notes.txt for the reason
52 why. */
53
54 #include "pub_core_basics.h" /* basic types */
55 #include "pub_core_vkiscnums.h" /* for syscall numbers */
56 #include "pub_core_debuglog.h" /* our own iface */
57 #include "valgrind.h" /* for RUNNING_ON_VALGRIND */
58
59 /*------------------------------------------------------------*/
60 /*--- Stuff to make us completely independent. ---*/
61 /*------------------------------------------------------------*/
62
63 /* ----- Platform-specifics ----- */
64
65 #if defined(VGP_x86_linux)
66
local_sys_write_stderr(HChar * buf,Int n)67 static UInt local_sys_write_stderr ( HChar* buf, Int n )
68 {
69 volatile Int block[2];
70 block[0] = (Int)buf;
71 block[1] = n;
72 __asm__ volatile (
73 "pushl %%ebx\n" /* ebx is callee-save */
74 "movl %0, %%ebx\n" /* ebx = &block */
75 "pushl %%ebx\n" /* save &block */
76 "movl 0(%%ebx), %%ecx\n" /* %ecx = buf */
77 "movl 4(%%ebx), %%edx\n" /* %edx = n */
78 "movl $"VG_STRINGIFY(__NR_write)", %%eax\n" /* %eax = __NR_write */
79 "movl $2, %%ebx\n" /* %ebx = stderr */
80 "int $0x80\n" /* write(stderr, buf, n) */
81 "popl %%ebx\n" /* reestablish &block */
82 "movl %%eax, 0(%%ebx)\n" /* block[0] = result */
83 "popl %%ebx\n" /* restore ebx */
84 : /*wr*/
85 : /*rd*/ "g" (block)
86 : /*trash*/ "eax", "edi", "ecx", "edx", "memory", "cc"
87 );
88 if (block[0] < 0)
89 block[0] = -1;
90 return block[0];
91 }
92
local_sys_getpid(void)93 static UInt local_sys_getpid ( void )
94 {
95 UInt __res;
96 __asm__ volatile (
97 "movl $"VG_STRINGIFY(__NR_getpid)", %%eax\n" /* %eax = __NR_getpid */
98 "int $0x80\n" /* getpid() */
99 "movl %%eax, %0\n" /* set __res = eax */
100 : "=mr" (__res)
101 :
102 : "eax" );
103 return __res;
104 }
105
106 #elif defined(VGP_amd64_linux)
107 __attribute__((noinline))
local_sys_write_stderr(HChar * buf,Int n)108 static UInt local_sys_write_stderr ( HChar* buf, Int n )
109 {
110 volatile Long block[2];
111 block[0] = (Long)buf;
112 block[1] = n;
113 __asm__ volatile (
114 "subq $256, %%rsp\n" /* don't trash the stack redzone */
115 "pushq %%r15\n" /* r15 is callee-save */
116 "movq %0, %%r15\n" /* r15 = &block */
117 "pushq %%r15\n" /* save &block */
118 "movq $"VG_STRINGIFY(__NR_write)", %%rax\n" /* rax = __NR_write */
119 "movq $2, %%rdi\n" /* rdi = stderr */
120 "movq 0(%%r15), %%rsi\n" /* rsi = buf */
121 "movq 8(%%r15), %%rdx\n" /* rdx = n */
122 "syscall\n" /* write(stderr, buf, n) */
123 "popq %%r15\n" /* reestablish &block */
124 "movq %%rax, 0(%%r15)\n" /* block[0] = result */
125 "popq %%r15\n" /* restore r15 */
126 "addq $256, %%rsp\n" /* restore stack ptr */
127 : /*wr*/
128 : /*rd*/ "g" (block)
129 : /*trash*/ "rax", "rdi", "rsi", "rdx", "memory", "cc"
130 );
131 if (block[0] < 0)
132 block[0] = -1;
133 return (UInt)block[0];
134 }
135
local_sys_getpid(void)136 static UInt local_sys_getpid ( void )
137 {
138 UInt __res;
139 __asm__ volatile (
140 "movq $"VG_STRINGIFY(__NR_getpid)", %%rax\n" /* %rax = __NR_getpid */
141 "syscall\n" /* getpid() */
142 "movl %%eax, %0\n" /* set __res = %eax */
143 : "=mr" (__res)
144 :
145 : "rax" );
146 return __res;
147 }
148
149 #elif defined(VGP_ppc32_linux)
150
local_sys_write_stderr(HChar * buf,Int n)151 static UInt local_sys_write_stderr ( HChar* buf, Int n )
152 {
153 volatile Int block[2];
154 block[0] = (Int)buf;
155 block[1] = n;
156 __asm__ volatile (
157 "addi 1,1,-256\n\t"
158 "mr 5,%0\n\t" /* r5 = &block[0] */
159 "stw 5,0(1)\n\t" /* stash on stack */
160 "li 0,"VG_STRINGIFY(__NR_write)"\n\t" /* set %r0 = __NR_write */
161 "li 3,2\n\t" /* set %r3 = stderr */
162 "lwz 4,0(5)\n\t" /* set %r4 = buf */
163 "lwz 5,4(5)\n\t" /* set %r5 = n */
164 "sc\n\t" /* write(stderr, buf, n) */
165 "lwz 5,0(1)\n\t"
166 "addi 1,1,256\n\t"
167 "stw 3,0(5)\n" /* block[0] = result */
168 :
169 : "b" (block)
170 : "cc","memory","cr0","ctr",
171 "r0","r2","r3","r4","r5","r6","r7","r8","r9","r10","r11","r12"
172 );
173 if (block[0] < 0)
174 block[0] = -1;
175 return (UInt)block[0];
176 }
177
local_sys_getpid(void)178 static UInt local_sys_getpid ( void )
179 {
180 register UInt __res __asm__ ("r3");
181 __asm__ volatile (
182 "li 0, %1\n\t"
183 "sc"
184 : "=&r" (__res)
185 : "i" (__NR_getpid)
186 : "cc","memory","cr0","ctr",
187 "r0","r2","r4","r5","r6","r7","r8","r9","r10","r11","r12"
188 );
189 return __res;
190 }
191
192 #elif defined(VGP_ppc64_linux)
193
local_sys_write_stderr(HChar * buf,Int n)194 static UInt local_sys_write_stderr ( HChar* buf, Int n )
195 {
196 volatile Long block[2];
197 block[0] = (Long)buf;
198 block[1] = (Long)n;
199 __asm__ volatile (
200 "addi 1,1,-256\n\t"
201 "mr 5,%0\n\t" /* r5 = &block[0] */
202 "std 5,0(1)\n\t" /* stash on stack */
203 "li 0,"VG_STRINGIFY(__NR_write)"\n\t" /* %r0 = __NR_write */
204 "li 3,2\n\t" /* set %r3 = stderr */
205 "ld 4,0(5)\n\t" /* set %r4 = buf */
206 "ld 5,8(5)\n\t" /* set %r5 = n */
207 "sc\n\t" /* write(stderr, buf, n) */
208 "ld 5,0(1)\n\t"
209 "addi 1,1,256\n\t"
210 "std 3,0(5)\n" /* block[0] = result */
211 :
212 : "b" (block)
213 : "cc","memory","cr0","ctr",
214 "r0","r2","r3","r4","r5","r6","r7","r8","r9","r10","r11","r12"
215 );
216 if (block[0] < 0)
217 block[0] = -1;
218 return (UInt)(Int)block[0];
219 }
220
local_sys_getpid(void)221 static UInt local_sys_getpid ( void )
222 {
223 register ULong __res __asm__ ("r3");
224 __asm__ volatile (
225 "li 0, %1\n\t"
226 "sc"
227 : "=&r" (__res)
228 : "i" (__NR_getpid)
229 : "cc","memory","cr0","ctr",
230 "r0","r2","r4","r5","r6","r7","r8","r9","r10","r11","r12"
231 );
232 return (UInt)__res;
233 }
234
235 #elif defined(VGP_arm_linux)
236
local_sys_write_stderr(HChar * buf,Int n)237 static UInt local_sys_write_stderr ( HChar* buf, Int n )
238 {
239 volatile Int block[2];
240 block[0] = (Int)buf;
241 block[1] = n;
242 __asm__ volatile (
243 "mov r0, #2\n\t" /* stderr */
244 "ldr r1, [%0]\n\t" /* buf */
245 "ldr r2, [%0, #4]\n\t" /* n */
246 "mov r7, #"VG_STRINGIFY(__NR_write)"\n\t"
247 "svc 0x0\n" /* write() */
248 "str r0, [%0]\n\t"
249 :
250 : "r" (block)
251 : "r0","r1","r2","r7"
252 );
253 if (block[0] < 0)
254 block[0] = -1;
255 return (UInt)block[0];
256 }
257
local_sys_getpid(void)258 static UInt local_sys_getpid ( void )
259 {
260 UInt __res;
261 __asm__ volatile (
262 "mov r7, #"VG_STRINGIFY(__NR_getpid)"\n"
263 "svc 0x0\n" /* getpid() */
264 "mov %0, r0\n"
265 : "=r" (__res)
266 :
267 : "r0", "r7" );
268 return __res;
269 }
270
271 #elif defined(VGP_ppc32_aix5)
272
local_sys_write_stderr(HChar * buf,Int n)273 static UInt local_sys_write_stderr ( HChar* buf, Int n )
274 {
275 /* For some reason gcc-3.3.2 doesn't preserve r31 across the asm
276 even though we state it to be trashed. So use r27 instead. */
277 volatile UInt block[3];
278 block[0] = (UInt)buf;
279 block[1] = n;
280 block[2] = __NR_write;
281 __asm__ __volatile__ (
282 "mr 28,%0\n\t" /* establish base ptr */
283 "mr 27,2\n\t" /* save r2 in r27 */
284 "mflr 30\n\t" /* save lr in r30 */
285
286 "lwz 2,8(28)\n\t" /* set %r2 = __NR_write */
287 "li 3,2\n\t" /* set %r3 = stderr */
288 "lwz 4,0(28)\n\t" /* set %r4 = buf */
289 "lwz 5,4(28)\n\t" /* set %r5 = n */
290
291 "crorc 6,6,6\n\t"
292 ".long 0x48000005\n\t" /* bl .+4 */
293 "mflr 29\n\t"
294 "addi 29,29,16\n\t"
295 "mtlr 29\n\t"
296 "sc\n\t" /* write() */
297
298 "stw 3,0(28)\n\t" /* result */
299 "stw 4,4(28)\n\t" /* error? */
300
301 "mr 2,27\n\t" /* restore r2 */
302 "mtlr 30" /* restore lr */
303
304 : /*out*/
305 : /*in*/ "b" (&block[0])
306 : /*trash*/
307 /*temps*/ "r31","r30","r29","r28","r27",
308 /*args*/ "r3","r4","r5","r6","r7","r8","r9","r10",
309 /*paranoia*/ "memory","cc","r0","r1","r11","r12","r13",
310 "xer","ctr","cr0","cr1","cr2","cr3",
311 "cr4","cr5","cr6","cr7"
312 );
313 if (block[1] != 0)
314 return -1;
315 else
316 return block[0];
317 }
318
local_sys_getpid(void)319 static UInt local_sys_getpid ( void )
320 {
321 /* For some reason gcc-3.3.2 doesn't preserve r31 across the asm
322 even though we state it to be trashed. So use r27 instead. */
323 volatile UInt block[1];
324 block[0] = __NR_getpid;
325 __asm__ __volatile__ (
326 "mr 28,%0\n\t" /* establish base ptr */
327 "mr 27,2\n\t" /* save r2 in r27 */
328 "mflr 30\n\t" /* save lr in r30 */
329
330 "lwz 2,0(28)\n\t" /* set %r2 = __NR_getpid */
331
332 "crorc 6,6,6\n\t"
333 ".long 0x48000005\n\t" /* bl .+4 */
334 "mflr 29\n\t"
335 "addi 29,29,16\n\t"
336 "mtlr 29\n\t"
337 "sc\n\t" /* getpid() */
338
339 "stw 3,0(28)\n\t" /* result -> block[0] */
340
341 "mr 2,27\n\t" /* restore r2 */
342 "mtlr 30" /* restore lr */
343
344 : /*out*/
345 : /*in*/ "b" (&block[0])
346 : /*trash*/
347 /*temps*/ "r31","r30","r29","r28","r27",
348 /*args*/ "r3","r4","r5","r6","r7","r8","r9","r10",
349 /*paranoia*/ "memory","cc","r0","r1","r11","r12","r13",
350 "xer","ctr","cr0","cr1","cr2","cr3",
351 "cr4","cr5","cr6","cr7"
352 );
353 return block[0];
354 }
355
356 #elif defined(VGP_ppc64_aix5)
357
local_sys_write_stderr(HChar * buf,Int n)358 static UInt local_sys_write_stderr ( HChar* buf, Int n )
359 {
360 volatile ULong block[3];
361 block[0] = (ULong)buf;
362 block[1] = n;
363 block[2] = (ULong)__NR_write;
364 __asm__ __volatile__ (
365 "mr 28,%0\n\t" /* establish base ptr */
366 "mr 27,2\n\t" /* save r2 in r27 */
367 "mflr 30\n\t" /* save lr in r30 */
368
369 "ld 2,16(28)\n\t" /* set %r2 = __NR_write */
370 "li 3,2\n\t" /* set %r3 = stderr */
371 "ld 4,0(28)\n\t" /* set %r4 = buf */
372 "ld 5,8(28)\n\t" /* set %r5 = n */
373
374 "crorc 6,6,6\n\t"
375 ".long 0x48000005\n\t" /* bl .+4 */
376 "mflr 29\n\t"
377 "addi 29,29,16\n\t"
378 "mtlr 29\n\t"
379 "sc\n\t" /* write() */
380
381 "std 3,0(28)\n\t" /* result */
382 "std 4,8(28)\n\t" /* error? */
383
384 "mr 2,27\n\t" /* restore r2 */
385 "mtlr 30" /* restore lr */
386
387 : /*out*/
388 : /*in*/ "b" (&block[0])
389 : /*trash*/
390 /*temps*/ "r31","r30","r29","r28","r27",
391 /*args*/ "r3","r4","r5","r6","r7","r8","r9","r10",
392 /*paranoia*/ "memory","cc","r0","r1","r11","r12","r13",
393 "xer","ctr","cr0","cr1","cr2","cr3",
394 "cr4","cr5","cr6","cr7"
395 );
396 if (block[1] != 0)
397 return (UInt)-1;
398 else
399 return (UInt)block[0];
400 }
401
local_sys_getpid(void)402 static UInt local_sys_getpid ( void )
403 {
404 volatile ULong block[1];
405 block[0] = __NR_getpid;
406 __asm__ __volatile__ (
407 "mr 28,%0\n\t" /* establish base ptr */
408 "mr 27,2\n\t" /* save r2 in r27 */
409 "mflr 30\n\t" /* save lr in r30 */
410
411 "ld 2,0(28)\n\t" /* set %r2 = __NR_getpid */
412
413 "crorc 6,6,6\n\t"
414 ".long 0x48000005\n\t" /* bl .+4 */
415 "mflr 29\n\t"
416 "addi 29,29,16\n\t"
417 "mtlr 29\n\t"
418 "sc\n\t" /* getpid() */
419
420 "std 3,0(28)\n\t" /* result -> block[0] */
421
422 "mr 2,27\n\t" /* restore r2 */
423 "mtlr 30" /* restore lr */
424
425 : /*out*/
426 : /*in*/ "b" (&block[0])
427 : /*trash*/
428 /*temps*/ "r31","r30","r29","r28","r27",
429 /*args*/ "r3","r4","r5","r6","r7","r8","r9","r10",
430 /*paranoia*/ "memory","cc","r0","r1","r11","r12","r13",
431 "xer","ctr","cr0","cr1","cr2","cr3",
432 "cr4","cr5","cr6","cr7"
433 );
434 return (UInt)block[0];
435 }
436
437 #elif defined(VGP_x86_darwin)
438
439 /* We would use VG_DARWIN_SYSNO_TO_KERNEL instead of VG_DARWIN_SYSNO_INDEX
440 except that the former has a C ternary ?: operator which isn't valid in
441 asm code. Both macros give the same results for Unix-class syscalls (which
442 these all are, as identified by the use of 'int 0x80'). */
443 __attribute__((noinline))
local_sys_write_stderr(HChar * buf,Int n)444 static UInt local_sys_write_stderr ( HChar* buf, Int n )
445 {
446 UInt __res;
447 __asm__ volatile (
448 "movl %2, %%eax\n" /* push n */
449 "pushl %%eax\n"
450 "movl %1, %%eax\n" /* push buf */
451 "pushl %%eax\n"
452 "movl $2, %%eax\n" /* push stderr */
453 "pushl %%eax\n"
454 "movl $"VG_STRINGIFY(VG_DARWIN_SYSNO_INDEX(__NR_write_nocancel))
455 ", %%eax\n"
456 "pushl %%eax\n" /* push fake return address */
457 "int $0x80\n" /* write(stderr, buf, n) */
458 "jnc 1f\n" /* jump if no error */
459 "movl $-1, %%eax\n" /* return -1 if error */
460 "1: "
461 "movl %%eax, %0\n" /* __res = eax */
462 "addl $16, %%esp\n" /* pop x4 */
463 : "=mr" (__res)
464 : "g" (buf), "g" (n)
465 : "eax", "edx", "cc"
466 );
467 return __res;
468 }
469
local_sys_getpid(void)470 static UInt local_sys_getpid ( void )
471 {
472 UInt __res;
473 __asm__ volatile (
474 "movl $"VG_STRINGIFY(VG_DARWIN_SYSNO_INDEX(__NR_getpid))", %%eax\n"
475 "int $0x80\n" /* getpid() */
476 "movl %%eax, %0\n" /* set __res = eax */
477 : "=mr" (__res)
478 :
479 : "eax", "cc" );
480 return __res;
481 }
482
483 #elif defined(VGP_amd64_darwin)
484
485 __attribute__((noinline))
local_sys_write_stderr(HChar * buf,Int n)486 static UInt local_sys_write_stderr ( HChar* buf, Int n )
487 {
488 UInt __res;
489 __asm__ volatile (
490 "movq $2, %%rdi\n" /* push stderr */
491 "movq %1, %%rsi\n" /* push buf */
492 "movl %2, %%edx\n" /* push n */
493 "movl $"VG_STRINGIFY(VG_DARWIN_SYSNO_FOR_KERNEL(__NR_write_nocancel))
494 ", %%eax\n"
495 "syscall\n" /* write(stderr, buf, n) */
496 "jnc 1f\n" /* jump if no error */
497 "movq $-1, %%rax\n" /* return -1 if error */
498 "1: "
499 "movl %%eax, %0\n" /* __res = eax */
500 : "=mr" (__res)
501 : "g" (buf), "g" (n)
502 : "rdi", "rsi", "rdx", "rcx", "rax", "cc" );
503 return __res;
504 }
505
local_sys_getpid(void)506 static UInt local_sys_getpid ( void )
507 {
508 UInt __res;
509 __asm__ volatile (
510 "movl $"VG_STRINGIFY(VG_DARWIN_SYSNO_FOR_KERNEL(__NR_getpid))", %%eax\n"
511 "syscall\n" /* getpid() */
512 "movl %%eax, %0\n" /* set __res = eax */
513 : "=mr" (__res)
514 :
515 : "rax", "rcx", "cc" );
516 return __res;
517 }
518
519 #else
520 # error Unknown platform
521 #endif
522
523
524 /* ----- generic ----- */
525
526 /* strlen, so we don't need m_libc */
local_strlen(const HChar * str)527 static Int local_strlen ( const HChar* str )
528 {
529 Int i = 0;
530 while (str[i] != 0) i++;
531 return i;
532 }
533
local_toupper(HChar c)534 static HChar local_toupper ( HChar c )
535 {
536 if (c >= 'a' && c <= 'z')
537 return c + ('A' - 'a');
538 else
539 return c;
540 }
541
542 /* Emit buf[0 .. n-1] to stderr. Unfortunately platform-specific.
543 */
emit(HChar * buf,Int n)544 static void emit ( HChar* buf, Int n )
545 {
546 if (n >= 1)
547 (void)local_sys_write_stderr(buf, n);
548 }
549
550
551 /*------------------------------------------------------------*/
552 /*--- A simple, generic, vprintf implementation. ---*/
553 /*------------------------------------------------------------*/
554
555 /* -----------------------------------------------
556 Distantly derived from:
557
558 vprintf replacement for Checker.
559 Copyright 1993, 1994, 1995 Tristan Gingold
560 Written September 1993 Tristan Gingold
561 Tristan Gingold, 8 rue Parmentier, F-91120 PALAISEAU, FRANCE
562
563 (Checker itself was GPL'd.)
564 ----------------------------------------------- */
565
566 /* Some flags. */
567 #define VG_MSG_SIGNED 1 /* The value is signed. */
568 #define VG_MSG_ZJUSTIFY 2 /* Must justify with '0'. */
569 #define VG_MSG_LJUSTIFY 4 /* Must justify on the left. */
570 #define VG_MSG_PAREN 8 /* Parenthesize if present (for %y) */
571 #define VG_MSG_COMMA 16 /* Add commas to numbers (for %d, %u) */
572 #define VG_MSG_ALTFORMAT 32 /* Convert the value to alternate format */
573
574 /* Copy a string into the buffer. */
575 static
myvprintf_str(void (* send)(HChar,void *),void * send_arg2,Int flags,Int width,HChar * str,Bool capitalise)576 UInt myvprintf_str ( void(*send)(HChar,void*),
577 void* send_arg2,
578 Int flags,
579 Int width,
580 HChar* str,
581 Bool capitalise )
582 {
583 # define MAYBE_TOUPPER(ch) (capitalise ? local_toupper(ch) : (ch))
584 UInt ret = 0;
585 Int i, extra;
586 Int len = local_strlen(str);
587
588 if (width == 0) {
589 ret += len;
590 for (i = 0; i < len; i++)
591 send(MAYBE_TOUPPER(str[i]), send_arg2);
592 return ret;
593 }
594
595 if (len > width) {
596 ret += width;
597 for (i = 0; i < width; i++)
598 send(MAYBE_TOUPPER(str[i]), send_arg2);
599 return ret;
600 }
601
602 extra = width - len;
603 if (flags & VG_MSG_LJUSTIFY) {
604 ret += extra;
605 for (i = 0; i < extra; i++)
606 send(' ', send_arg2);
607 }
608 ret += len;
609 for (i = 0; i < len; i++)
610 send(MAYBE_TOUPPER(str[i]), send_arg2);
611 if (!(flags & VG_MSG_LJUSTIFY)) {
612 ret += extra;
613 for (i = 0; i < extra; i++)
614 send(' ', send_arg2);
615 }
616
617 # undef MAYBE_TOUPPER
618 return ret;
619 }
620
621
622 /* Copy a string into the buffer, escaping bad XML chars. */
623 static
myvprintf_str_XML_simplistic(void (* send)(HChar,void *),void * send_arg2,HChar * str)624 UInt myvprintf_str_XML_simplistic ( void(*send)(HChar,void*),
625 void* send_arg2,
626 HChar* str )
627 {
628 UInt ret = 0;
629 Int i;
630 Int len = local_strlen(str);
631 HChar* alt;
632
633 for (i = 0; i < len; i++) {
634 switch (str[i]) {
635 case '&': alt = "&"; break;
636 case '<': alt = "<"; break;
637 case '>': alt = ">"; break;
638 default: alt = NULL;
639 }
640
641 if (alt) {
642 while (*alt) {
643 send(*alt, send_arg2);
644 ret++;
645 alt++;
646 }
647 } else {
648 send(str[i], send_arg2);
649 ret++;
650 }
651 }
652
653 return ret;
654 }
655
656
657 /* Write P into the buffer according to these args:
658 * If SIGN is true, p is a signed.
659 * BASE is the base.
660 * If WITH_ZERO is true, '0' must be added.
661 * WIDTH is the width of the field.
662 */
663 static
myvprintf_int64(void (* send)(HChar,void *),void * send_arg2,Int flags,Int base,Int width,Bool capitalised,ULong p)664 UInt myvprintf_int64 ( void(*send)(HChar,void*),
665 void* send_arg2,
666 Int flags,
667 Int base,
668 Int width,
669 Bool capitalised,
670 ULong p )
671 {
672 HChar buf[40];
673 Int ind = 0;
674 Int i, nc = 0;
675 Bool neg = False;
676 HChar* digits = capitalised ? "0123456789ABCDEF" : "0123456789abcdef";
677 UInt ret = 0;
678
679 if (base < 2 || base > 16)
680 return ret;
681
682 if ((flags & VG_MSG_SIGNED) && (Long)p < 0) {
683 p = - (Long)p;
684 neg = True;
685 }
686
687 if (p == 0)
688 buf[ind++] = '0';
689 else {
690 while (p > 0) {
691 if (flags & VG_MSG_COMMA && 10 == base &&
692 0 == (ind-nc) % 3 && 0 != ind)
693 {
694 buf[ind++] = ',';
695 nc++;
696 }
697 buf[ind++] = digits[p % base];
698 p /= base;
699 }
700 }
701
702 if (neg)
703 buf[ind++] = '-';
704
705 if (width > 0 && !(flags & VG_MSG_LJUSTIFY)) {
706 for(; ind < width; ind++) {
707 /* vg_assert(ind < 39); */
708 if (ind > 39) {
709 buf[39] = 0;
710 break;
711 }
712 buf[ind] = (flags & VG_MSG_ZJUSTIFY) ? '0': ' ';
713 }
714 }
715
716 /* Reverse copy to buffer. */
717 ret += ind;
718 for (i = ind -1; i >= 0; i--) {
719 send(buf[i], send_arg2);
720 }
721 if (width > 0 && (flags & VG_MSG_LJUSTIFY)) {
722 for(; ind < width; ind++) {
723 ret++;
724 /* Never pad with zeroes on RHS -- changes the value! */
725 send(' ', send_arg2);
726 }
727 }
728 return ret;
729 }
730
731
732 /* A simple vprintf(). */
733 /* EXPORTED */
734 UInt
VG_(debugLog_vprintf)735 VG_(debugLog_vprintf) (
736 void(*send)(HChar,void*),
737 void* send_arg2,
738 const HChar* format,
739 va_list vargs
740 )
741 {
742 UInt ret = 0;
743 Int i;
744 Int flags;
745 Int width;
746 Int n_ls = 0;
747 Bool is_long, caps;
748
749 /* We assume that vargs has already been initialised by the
750 caller, using va_start, and that the caller will similarly
751 clean up with va_end.
752 */
753
754 for (i = 0; format[i] != 0; i++) {
755 if (format[i] != '%') {
756 send(format[i], send_arg2);
757 ret++;
758 continue;
759 }
760 i++;
761 /* A '%' has been found. Ignore a trailing %. */
762 if (format[i] == 0)
763 break;
764 if (format[i] == '%') {
765 /* '%%' is replaced by '%'. */
766 send('%', send_arg2);
767 ret++;
768 continue;
769 }
770 flags = 0;
771 n_ls = 0;
772 width = 0; /* length of the field. */
773 while (1) {
774 switch (format[i]) {
775 case '(':
776 flags |= VG_MSG_PAREN;
777 break;
778 case ',':
779 case '\'':
780 /* If ',' or '\'' follows '%', commas will be inserted. */
781 flags |= VG_MSG_COMMA;
782 break;
783 case '-':
784 /* If '-' follows '%', justify on the left. */
785 flags |= VG_MSG_LJUSTIFY;
786 break;
787 case '0':
788 /* If '0' follows '%', pads will be inserted. */
789 flags |= VG_MSG_ZJUSTIFY;
790 break;
791 case '#':
792 /* If '#' follows '%', alternative format will be used. */
793 flags |= VG_MSG_ALTFORMAT;
794 break;
795 default:
796 goto parse_fieldwidth;
797 }
798 i++;
799 }
800 parse_fieldwidth:
801 /* Compute the field length. */
802 while (format[i] >= '0' && format[i] <= '9') {
803 width *= 10;
804 width += format[i++] - '0';
805 }
806 while (format[i] == 'l') {
807 i++;
808 n_ls++;
809 }
810
811 // %d means print a 32-bit integer.
812 // %ld means print a word-size integer.
813 // %lld means print a 64-bit integer.
814 if (0 == n_ls) { is_long = False; }
815 else if (1 == n_ls) { is_long = ( sizeof(void*) == sizeof(Long) ); }
816 else { is_long = True; }
817
818 switch (format[i]) {
819 case 'o': /* %o */
820 if (flags & VG_MSG_ALTFORMAT) {
821 ret += 2;
822 send('0',send_arg2);
823 }
824 if (is_long)
825 ret += myvprintf_int64(send, send_arg2, flags, 8, width, False,
826 (ULong)(va_arg (vargs, ULong)));
827 else
828 ret += myvprintf_int64(send, send_arg2, flags, 8, width, False,
829 (ULong)(va_arg (vargs, UInt)));
830 break;
831 case 'd': /* %d */
832 flags |= VG_MSG_SIGNED;
833 if (is_long)
834 ret += myvprintf_int64(send, send_arg2, flags, 10, width, False,
835 (ULong)(va_arg (vargs, Long)));
836 else
837 ret += myvprintf_int64(send, send_arg2, flags, 10, width, False,
838 (ULong)(va_arg (vargs, Int)));
839 break;
840 case 'u': /* %u */
841 if (is_long)
842 ret += myvprintf_int64(send, send_arg2, flags, 10, width, False,
843 (ULong)(va_arg (vargs, ULong)));
844 else
845 ret += myvprintf_int64(send, send_arg2, flags, 10, width, False,
846 (ULong)(va_arg (vargs, UInt)));
847 break;
848 case 'p': /* %p */
849 ret += 2;
850 send('0',send_arg2);
851 send('x',send_arg2);
852 ret += myvprintf_int64(send, send_arg2, flags, 16, width, True,
853 (ULong)((UWord)va_arg (vargs, void *)));
854 break;
855 case 'x': /* %x */
856 case 'X': /* %X */
857 caps = toBool(format[i] == 'X');
858 if (flags & VG_MSG_ALTFORMAT) {
859 ret += 2;
860 send('0',send_arg2);
861 send('x',send_arg2);
862 }
863 if (is_long)
864 ret += myvprintf_int64(send, send_arg2, flags, 16, width, caps,
865 (ULong)(va_arg (vargs, ULong)));
866 else
867 ret += myvprintf_int64(send, send_arg2, flags, 16, width, caps,
868 (ULong)(va_arg (vargs, UInt)));
869 break;
870 case 'c': /* %c */
871 ret++;
872 send(va_arg (vargs, int), send_arg2);
873 break;
874 case 's': case 'S': { /* %s */
875 char *str = va_arg (vargs, char *);
876 if (str == (char*) 0) str = "(null)";
877 ret += myvprintf_str(send, send_arg2,
878 flags, width, str, format[i]=='S');
879 break;
880 }
881 case 't': { /* %t, like %s but escaping chars for XML safety */
882 /* Note: simplistic; ignores field width and flags */
883 char *str = va_arg (vargs, char *);
884 if (str == (char*) 0) str = "(null)";
885 ret += myvprintf_str_XML_simplistic(send, send_arg2, str);
886 break;
887 }
888
889 // case 'y': { /* %y - print symbol */
890 // Char buf[100];
891 // Char *cp = buf;
892 // Addr a = va_arg(vargs, Addr);
893 //
894 // if (flags & VG_MSG_PAREN)
895 // *cp++ = '(';
896 // if (VG_(get_fnname_w_offset)(a, cp, sizeof(buf)-4)) {
897 // if (flags & VG_MSG_PAREN) {
898 // cp += VG_(strlen)(cp);
899 // *cp++ = ')';
900 // *cp = '\0';
901 // }
902 // ret += myvprintf_str(send, send_arg2, flags, width, buf, 0);
903 // }
904 // break;
905 // }
906 default:
907 break;
908 }
909 }
910 return ret;
911 }
912
913
914 /*------------------------------------------------------------*/
915 /*--- Debuglog stuff. ---*/
916 /*------------------------------------------------------------*/
917
918 /* Only print messages whose stated level is less than or equal to
919 this. By default, it makes this entire subsystem silent. */
920
921 static Int loglevel = 0;
922
923 /* Module startup. */
924 /* EXPORTED */
VG_(debugLog_startup)925 void VG_(debugLog_startup) ( Int level, HChar* who )
926 {
927 if (level < 0) level = 0;
928 if (level > 10) level = 10;
929 loglevel = level;
930 VG_(debugLog)(1, "debuglog",
931 "DebugLog system started by %s, "
932 "level %d logging requested\n",
933 who, loglevel);
934 }
935
936 /* Get the logging threshold level, as set by the most recent call to
937 VG_(debugLog_startup), or zero if there have been no such calls so
938 far. */
939 /* EXPORTED */
VG_(debugLog_getLevel)940 Int VG_(debugLog_getLevel) ( void )
941 {
942 return loglevel;
943 }
944
945
946 /* ------------ */
947
948 typedef
949 struct {
950 HChar buf[100];
951 Int n;
952 }
953 printf_buf;
954
add_to_buf(HChar c,void * p)955 static void add_to_buf ( HChar c, void* p )
956 {
957 printf_buf* buf = (printf_buf*)p;
958
959 if (buf->n >= 100-10 /*paranoia*/ ) {
960 emit( buf->buf, local_strlen(buf->buf) );
961 buf->n = 0;
962 buf->buf[buf->n] = 0;
963 }
964 buf->buf[buf->n++] = c;
965 buf->buf[buf->n] = 0;
966 }
967
968 /* Send a logging message. Nothing is output unless 'level'
969 is <= the current loglevel. */
970 /* EXPORTED */
VG_(debugLog)971 void VG_(debugLog) ( Int level, const HChar* modulename,
972 const HChar* format, ... )
973 {
974 UInt ret, pid;
975 Int indent, depth, i;
976 va_list vargs;
977 printf_buf buf;
978
979 if (level > loglevel)
980 return;
981
982 indent = 2*level - 1;
983 if (indent < 1) indent = 1;
984
985 buf.n = 0;
986 buf.buf[0] = 0;
987 pid = local_sys_getpid();
988
989 // Print one '>' in front of the messages for each level of self-hosting
990 // being performed.
991 depth = RUNNING_ON_VALGRIND;
992 for (i = 0; i < depth; i++) {
993 (void)myvprintf_str ( add_to_buf, &buf, 0, 1, ">", False );
994 }
995
996 (void)myvprintf_str ( add_to_buf, &buf, 0, 2, "--", False );
997 (void)myvprintf_int64 ( add_to_buf, &buf, 0, 10, 1, False, (ULong)pid );
998 (void)myvprintf_str ( add_to_buf, &buf, 0, 1, ":", False );
999 (void)myvprintf_int64 ( add_to_buf, &buf, 0, 10, 1, False, (ULong)level );
1000 (void)myvprintf_str ( add_to_buf, &buf, 0, 1, ":", False );
1001 (void)myvprintf_str ( add_to_buf, &buf, 0, 8, (HChar*)modulename, False );
1002 (void)myvprintf_str ( add_to_buf, &buf, 0, indent, "", False );
1003
1004 va_start(vargs,format);
1005
1006 ret = VG_(debugLog_vprintf) ( add_to_buf, &buf, format, vargs );
1007
1008 if (buf.n > 0) {
1009 emit( buf.buf, local_strlen(buf.buf) );
1010 }
1011
1012 va_end(vargs);
1013 }
1014
1015
1016
1017 /*--------------------------------------------------------------------*/
1018 /*--- end m_debuglog.c ---*/
1019 /*--------------------------------------------------------------------*/
1020