coregrind/m_libcprint.c

   1 /* -*- mode: C; c-basic-offset: 3; -*- */
   2
   3 /*--------------------------------------------------------------------*/
   4 /*--- Libc printing.                                 m_libcprint.c ---*/
   5 /*--------------------------------------------------------------------*/
   6
   7 /*
   8    This file is part of Valgrind, a dynamic binary instrumentation
   9    framework.
  10
  11    Copyright (C) 2000-2013 Julian Seward
  12       jseward@acm.org
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of the
  17    License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  27    02111-1307, USA.
  28
  29    The GNU General Public License is contained in the file COPYING.
  30 */
  31
  32 #include "pub_core_basics.h"
  33 #include "pub_core_vki.h"
  34 #include "pub_core_debuglog.h"
  35 #include "pub_core_gdbserver.h"  // VG_(gdb_printf)
  36 #include "pub_core_libcbase.h"
  37 #include "pub_core_libcassert.h"
  38 #include "pub_core_libcfile.h"   // VG_(write)(), VG_(write_socket)()
  39 #include "pub_core_libcprint.h"
  40 #include "pub_core_libcproc.h"   // VG_(getpid)(), VG_(read_millisecond_timer()
  41 #include "pub_core_mallocfree.h" // VG_(malloc)
  42 #include "pub_core_options.h"
  43 #include "pub_core_clreq.h"      // For RUNNING_ON_VALGRIND
  44
  45
  46 /* ---------------------------------------------------------------------
  47    Writing to file or a socket
  48    ------------------------------------------------------------------ */
  49
  50 /* The destination sinks for normal and XML output.  These have their
  51    initial values here; they are set to final values by
  52    m_main.main_process_cmd_line_options().  See comment at the top of
  53    that function for the associated logic.
  54    After startup, the gdbserver monitor command might temporarily
  55    set the fd of log_output_sink to -2 to indicate that output is
  56    to be given to gdb rather than output to the startup fd */
  57 OutputSink VG_(log_output_sink) = {  2, False }; /* 2 = stderr */
  58 OutputSink VG_(xml_output_sink) = { -1, False }; /* disabled */
  59
  60 /* Do the low-level send of a message to the logging sink. */
  61 static
  62 void send_bytes_to_logging_sink ( OutputSink* sink, const HChar* msg, Int nbytes )
  63 {
  64    if (sink->is_socket) {
  65       Int rc = VG_(write_socket)( sink->fd, msg, nbytes );
  66       if (rc == -1) {
  67          // For example, the listener process died.  Switch back to stderr.
  68          sink->is_socket = False;
  69          sink->fd = 2;
  70          VG_(write)( sink->fd, msg, nbytes );
  71       }
  72    } else {
  73       /* sink->fd could have been set to -1 in the various
  74          sys-wrappers for sys_fork, if --child-silent-after-fork=yes
  75          is in effect.  That is a signal that we should not produce
  76          any more output. */
  77       if (sink->fd >= 0)
  78          VG_(write)( sink->fd, msg, nbytes );
  79       else if (sink->fd == -2 && nbytes > 0)
  80          /* send to gdb the provided data, which must be
  81             a null terminated string with len >= 1 */
  82          VG_(gdb_printf)("%s", msg);
  83    }
  84 }
  85
  86
  87 /* ---------------------------------------------------------------------
  88    printf() and friends
  89    ------------------------------------------------------------------ */
  90
  91 /* --------- printf --------- */
  92
  93 typedef
  94    struct {
  95       HChar       buf[512];
  96       Int         buf_used;
  97       OutputSink* sink;
  98    }
  99    printf_buf_t;
 100
 101 // Adds a single char to the buffer.  When the buffer gets sufficiently
 102 // full, we write its contents to the logging sink.
 103 static void add_to__printf_buf ( HChar c, void *p )
 104 {
 105    printf_buf_t *b = (printf_buf_t *)p;
 106
 107    if (b->buf_used > sizeof(b->buf) - 2 ) {
 108       send_bytes_to_logging_sink( b->sink, b->buf, b->buf_used );
 109       b->buf_used = 0;
 110    }
 111    b->buf[b->buf_used++] = c;
 112    b->buf[b->buf_used]   = 0;
 113    vg_assert(b->buf_used < sizeof(b->buf));
 114 }
 115
 116 static UInt vprintf_to_buf ( printf_buf_t* b,
 117                              const HChar *format, va_list vargs )
 118 {
 119    UInt ret = 0;
 120    if (b->sink->fd >= 0 || b->sink->fd == -2) {
 121       ret = VG_(debugLog_vprintf)
 122                ( add_to__printf_buf, b, format, vargs );
 123    }
 124    return ret;
 125 }
 126
 127 static UInt vprintf_WRK ( OutputSink* sink,
 128                           const HChar *format, va_list vargs )
 129 {
 130    printf_buf_t myprintf_buf
 131       = { "", 0, sink };
 132    UInt ret
 133       = vprintf_to_buf(&myprintf_buf, format, vargs);
 134    // Write out any chars left in the buffer.
 135    if (myprintf_buf.buf_used > 0) {
 136       send_bytes_to_logging_sink( myprintf_buf.sink,
 137                                   myprintf_buf.buf,
 138                                   myprintf_buf.buf_used );
 139    }
 140    return ret;
 141 }
 142
 143 UInt VG_(vprintf) ( const HChar *format, va_list vargs )
 144 {
 145    return vprintf_WRK( &VG_(log_output_sink), format, vargs );
 146 }
 147
 148 UInt VG_(printf) ( const HChar *format, ... )
 149 {
 150    UInt ret;
 151    va_list vargs;
 152    va_start(vargs, format);
 153    ret = VG_(vprintf)(format, vargs);
 154    va_end(vargs);
 155    return ret;
 156 }
 157
 158 UInt VG_(vprintf_xml) ( const HChar *format, va_list vargs )
 159 {
 160    return vprintf_WRK( &VG_(xml_output_sink), format, vargs );
 161 }
 162
 163 UInt VG_(printf_xml) ( const HChar *format, ... )
 164 {
 165    UInt ret;
 166    va_list vargs;
 167    va_start(vargs, format);
 168    ret = VG_(vprintf_xml)(format, vargs);
 169    va_end(vargs);
 170    return ret;
 171 }
 172
 173 static UInt emit_WRK ( const HChar* format, va_list vargs )
 174 {
 175    if (VG_(clo_xml)) {
 176       return VG_(vprintf_xml)(format, vargs);
 177    } else if (VG_(log_output_sink).fd == -2) {
 178       return VG_(vprintf) (format, vargs);
 179    } else {
 180       return VG_(vmessage)(Vg_UserMsg, format, vargs);
 181    }
 182 }
 183 UInt VG_(emit) ( const HChar* format, ... )
 184 {
 185    UInt ret;
 186    va_list vargs;
 187    va_start(vargs, format);
 188    ret = emit_WRK(format, vargs);
 189    va_end(vargs);
 190    return ret;
 191 }
 192
 193 /* --------- sprintf --------- */
 194
 195 /* If we had an explicit buf structure here, it would contain only one
 196    field, indicating where the next char is to go.  So use p directly
 197    for that, rather than having it be a pointer to a structure. */
 198
 199 static void add_to__sprintf_buf ( HChar c, void *p )
 200 {
 201    HChar** b = p;
 202    *(*b)++ = c;
 203 }
 204
 205 UInt VG_(vsprintf) ( HChar* buf, const HChar *format, va_list vargs )
 206 {
 207    Int ret;
 208    HChar* sprintf_ptr = buf;
 209
 210    ret = VG_(debugLog_vprintf)
 211             ( add_to__sprintf_buf, &sprintf_ptr, format, vargs );
 212    add_to__sprintf_buf('\0', &sprintf_ptr);
 213
 214    vg_assert(VG_(strlen)(buf) == ret);
 215
 216    return ret;
 217 }
 218
 219 UInt VG_(sprintf) ( HChar* buf, const HChar *format, ... )
 220 {
 221    UInt ret;
 222    va_list vargs;
 223    va_start(vargs,format);
 224    ret = VG_(vsprintf)(buf, format, vargs);
 225    va_end(vargs);
 226    return ret;
 227 }
 228
 229
 230 /* --------- snprintf --------- */
 231
 232 /* The return value of VG_(snprintf) and VG_(vsnprintf) differs from
 233    what is defined in C99. Let S be the size of the buffer as given in
 234    the 2nd argument.
 235    Return value R:
 236      R < S:  The output string was successfully written to the buffer.
 237              It is null-terminated and R == strlen( output string )
 238      R == S: The supplied buffer was too small to hold the output string.
 239              The first S-1 characters of the output string were written
 240              to the buffer followed by the terminating null character.
 241 */
 242
 243 typedef
 244    struct {
 245       HChar* buf;
 246       Int    buf_size;
 247       Int    buf_used;
 248    }
 249    snprintf_buf_t;
 250
 251 static void add_to__snprintf_buf ( HChar c, void* p )
 252 {
 253    snprintf_buf_t* b = p;
 254    if (b->buf_size > 0 && b->buf_used < b->buf_size) {
 255       b->buf[b->buf_used++] = c;
 256       if (b->buf_used < b->buf_size)
 257          b->buf[b->buf_used] = 0;
 258       else
 259          b->buf[b->buf_size-1] = 0; /* pre: b->buf_size > 0 */
 260    }
 261 }
 262
 263 UInt VG_(vsnprintf) ( HChar* buf, Int size, const HChar *format, va_list vargs )
 264 {
 265    snprintf_buf_t b;
 266    b.buf      = buf;
 267    b.buf_size = size < 0 ? 0 : size;
 268    b.buf_used = 0;
 269    if (b.buf_size > 0)
 270       b.buf[0] = 0; // ensure to null terminate buf if empty format
 271    (void) VG_(debugLog_vprintf)
 272              ( add_to__snprintf_buf, &b, format, vargs );
 273
 274    return b.buf_used;
 275 }
 276
 277 UInt VG_(snprintf) ( HChar* buf, Int size, const HChar *format, ... )
 278 {
 279    UInt ret;
 280    va_list vargs;
 281    va_start(vargs,format);
 282    ret = VG_(vsnprintf)(buf, size, format, vargs);
 283    va_end(vargs);
 284    return ret;
 285 }
 286
 287
 288 /* --------- vcbprintf --------- */
 289
 290 void VG_(vcbprintf)( void(*char_sink)(HChar, void* opaque),
 291                      void* opaque,
 292                      const HChar* format, va_list vargs )
 293 {
 294    (void) VG_(debugLog_vprintf)
 295              ( char_sink, opaque, format, vargs );
 296 }
 297
 298
 299 /* --------- fprintf ---------- */
 300
 301 /* This is like [v]fprintf, except it writes to a file handle using
 302    VG_(write). */
 303
 304 #define VGFILE_BUFSIZE  8192
 305
 306 struct _VgFile {
 307    HChar buf[VGFILE_BUFSIZE];
 308    UInt  num_chars;   // number of characters in buf
 309    Int   fd;          // file descriptor to write to
 310 };
 311
 312
 313 static void add_to__vgfile ( HChar c, void *p )
 314 {
 315    VgFile *fp = p;
 316
 317    fp->buf[fp->num_chars++] = c;
 318
 319    if (fp->num_chars == VGFILE_BUFSIZE) {
 320       VG_(write)(fp->fd, fp->buf, fp->num_chars);
 321       fp->num_chars = 0;
 322    }
 323 }
 324
 325 VgFile *VG_(fopen)(const HChar *name, Int flags, Int mode)
 326 {
 327    SysRes res = VG_(open)(name, flags, mode);
 328
 329    if (sr_isError(res))
 330       return NULL;
 331
 332    VgFile *fp = VG_(malloc)("fopen", sizeof(VgFile));
 333
 334    fp->fd = sr_Res(res);
 335    fp->num_chars = 0;
 336
 337    return fp;
 338 }
 339
 340
 341 UInt VG_(vfprintf) ( VgFile *fp, const HChar *format, va_list vargs )
 342 {
 343    return VG_(debugLog_vprintf)(add_to__vgfile, fp, format, vargs);
 344 }
 345
 346 UInt VG_(fprintf) ( VgFile *fp, const HChar *format, ... )
 347 {
 348    UInt ret;
 349    va_list vargs;
 350    va_start(vargs,format);
 351    ret = VG_(vfprintf)(fp, format, vargs);
 352    va_end(vargs);
 353    return ret;
 354 }
 355
 356 void VG_(fclose)( VgFile *fp )
 357 {
 358    // Flush the buffer.
 359    if (fp->num_chars)
 360       VG_(write)(fp->fd, fp->buf, fp->num_chars);
 361
 362    VG_(free)(fp);
 363 }
 364
 365 /* ---------------------------------------------------------------------
 366    percentify()
 367    ------------------------------------------------------------------ */
 368
 369 // Percentify n/m with d decimal places.  Includes the '%' symbol at the end.
 370 // Right justifies in 'buf'.
 371 void VG_(percentify)(ULong n, ULong m, UInt d, Int n_buf, HChar buf[])
 372 {
 373    Int i, len, space;
 374    ULong p1;
 375    HChar fmt[32];   // large enough
 376
 377    if (m == 0) {
 378       // Have to generate the format string in order to be flexible about
 379       // the width of the field.
 380       VG_(sprintf)(fmt, "%%%ds", n_buf);
 381       // fmt is now "%<n_buf>s" where <d> is 1,2,3...
 382       VG_(sprintf)(buf, fmt, "--%");
 383       return;
 384    }
 385
 386    p1 = (100*n) / m;
 387
 388    if (d == 0) {
 389       VG_(sprintf)(buf, "%llu%%", p1);  // FIXME: unsafe
 390    } else {
 391       ULong p2;
 392       UInt  ex;
 393       switch (d) {
 394       case 1: ex = 10;    break;
 395       case 2: ex = 100;   break;
 396       case 3: ex = 1000;  break;
 397       default: VG_(core_panic)("Currently can only handle 3 decimal places");
 398       }
 399       p2 = ((100*n*ex) / m) % ex;
 400       // Have to generate the format string in order to be flexible about
 401       // the width of the post-decimal-point part.
 402       VG_(sprintf)(fmt, "%%llu.%%0%ullu%%%%", d);
 403       // fmt is now "%llu.%0<d>llu%%" where <d> is 1,2,3...
 404       VG_(sprintf)(buf, fmt, p1, p2);   // FIXME: unsafe
 405    }
 406
 407    len = VG_(strlen)(buf);
 408    space = n_buf - len;
 409    if (space < 0) space = 0;     /* Allow for v. small field_width */
 410    i = len;
 411
 412    /* Right justify in field */
 413    for (     ; i >= 0;    i--)  buf[i + space] = buf[i];
 414    for (i = 0; i < space; i++)  buf[i] = ' ';
 415 }
 416
 417
 418 /* ---------------------------------------------------------------------
 419    elapsed_wallclock_time()
 420    ------------------------------------------------------------------ */
 421
 422 /* Get the elapsed wallclock time since startup into buf, which must
 423    16 chars long.  This is unchecked.  It also relies on the
 424    millisecond timer having been set to zero by an initial read in
 425    m_main during startup. */
 426
 427 void VG_(elapsed_wallclock_time) ( /*OUT*/HChar* buf, SizeT bufsize )
 428 {
 429    UInt t, ms, s, mins, hours, days;
 430
 431    vg_assert(bufsize > 20);
 432
 433    t  = VG_(read_millisecond_timer)(); /* milliseconds */
 434
 435    ms = t % 1000;
 436    t /= 1000; /* now in seconds */
 437
 438    s = t % 60;
 439    t /= 60; /* now in minutes */
 440
 441    mins = t % 60;
 442    t /= 60; /* now in hours */
 443
 444    hours = t % 24;
 445    t /= 24; /* now in days */
 446
 447    days = t;
 448
 449    VG_(sprintf)(buf, "%02u:%02u:%02u:%02u.%03u ", days, hours, mins, s, ms);
 450 }
 451
 452
 453 /* ---------------------------------------------------------------------
 454    message()
 455    ------------------------------------------------------------------ */
 456
 457 /* A buffer for accumulating VG_(message) style output.  This is
 458    pretty much the same as VG_(printf)'s scheme, with two differences:
 459
 460    * The message buffer persists between calls, so that multiple
 461      calls to VG_(message) can build up output.
 462
 463    * Whenever the first character on a line is emitted, the
 464      ==PID== style preamble is stuffed in before it.
 465 */
 466 typedef
 467    struct {
 468       HChar buf[512+128];
 469       Int   buf_used;
 470       Bool  atLeft; /* notionally, is the next char position at the
 471                        leftmost column? */
 472       /* Current message kind - changes from call to call */
 473       VgMsgKind kind;
 474       /* destination */
 475       OutputSink* sink;
 476    }
 477    vmessage_buf_t;
 478
 479 static vmessage_buf_t vmessage_buf
 480    = { "", 0, True, Vg_UserMsg, &VG_(log_output_sink) };
 481
 482
 483 // Adds a single char to the buffer.  We aim to have at least 128
 484 // bytes free in the buffer, so that it's always possible to emit
 485 // the preamble into the buffer if c happens to be the character
 486 // following a \n.  When the buffer gets too full, we write its
 487 // contents to the logging sink.
 488 static void add_to__vmessage_buf ( HChar c, void *p )
 489 {
 490    HChar tmp[64];
 491    vmessage_buf_t* b = (vmessage_buf_t*)p;
 492
 493    vg_assert(b->buf_used >= 0 && b->buf_used < sizeof(b->buf)-128);
 494
 495    if (UNLIKELY(b->atLeft)) {
 496       // insert preamble
 497       HChar ch;
 498       Int   i, depth;
 499
 500       // Print one '>' in front of the messages for each level of
 501       // self-hosting being performed.
 502       // Do not print such '>' if sim hint "no-inner-prefix" given
 503       // (useful to run regression tests in an outer/inner setup
 504       // and avoid the diff failing due to these unexpected '>').
 505       depth = RUNNING_ON_VALGRIND;
 506       if (depth > 0
 507           && !SimHintiS(SimHint_no_inner_prefix, VG_(clo_sim_hints))) {
 508          if (depth > 10)
 509             depth = 10; // ?!?!
 510          for (i = 0; i < depth; i++) {
 511             b->buf[b->buf_used++] = '>';
 512          }
 513       }
 514
 515       if (Vg_FailMsg == b->kind) {
 516          // "valgrind: " prefix.
 517          b->buf[b->buf_used++] = 'v';
 518          b->buf[b->buf_used++] = 'a';
 519          b->buf[b->buf_used++] = 'l';
 520          b->buf[b->buf_used++] = 'g';
 521          b->buf[b->buf_used++] = 'r';
 522          b->buf[b->buf_used++] = 'i';
 523          b->buf[b->buf_used++] = 'n';
 524          b->buf[b->buf_used++] = 'd';
 525          b->buf[b->buf_used++] = ':';
 526          b->buf[b->buf_used++] = ' ';
 527       } else {
 528          switch (b->kind) {
 529             case Vg_UserMsg:       ch = '='; break;
 530             case Vg_DebugMsg:      ch = '-'; break;
 531             case Vg_ClientMsg:     ch = '*'; break;
 532             default:               ch = '?'; break;
 533          }
 534
 535          b->buf[b->buf_used++] = ch;
 536          b->buf[b->buf_used++] = ch;
 537
 538          if (VG_(clo_time_stamp)) {
 539             VG_(elapsed_wallclock_time)(tmp, sizeof tmp);
 540             for (i = 0; tmp[i]; i++)
 541                b->buf[b->buf_used++] = tmp[i];
 542          }
 543
 544          VG_(sprintf)(tmp, "%d", VG_(getpid)());
 545          tmp[sizeof(tmp)-1] = 0;
 546          for (i = 0; tmp[i]; i++)
 547             b->buf[b->buf_used++] = tmp[i];
 548
 549          b->buf[b->buf_used++] = ch;
 550          b->buf[b->buf_used++] = ch;
 551          b->buf[b->buf_used++] = ' ';
 552       }
 553
 554       /* We can't possibly have stuffed 96 chars in merely as a result
 555          of making the preamble (can we?) */
 556       vg_assert(b->buf_used < sizeof(b->buf)-32);
 557    }
 558
 559    b->buf[b->buf_used++] = c;
 560    b->buf[b->buf_used]   = 0;
 561
 562    if (b->buf_used >= sizeof(b->buf) - 128) {
 563       send_bytes_to_logging_sink( b->sink, b->buf, b->buf_used );
 564       b->buf_used = 0;
 565    }
 566
 567    b->atLeft = c == '\n';
 568 }
 569
 570
 571 UInt VG_(vmessage) ( VgMsgKind kind, const HChar* format, va_list vargs )
 572 {
 573    UInt ret;
 574
 575    /* Note (carefully) that the buf persists from call to call, unlike
 576       with the other printf variants in earlier parts of this file. */
 577    vmessage_buf_t* b = &vmessage_buf; /* shorthand for convenience */
 578
 579    /* We have to set this each call, so that the correct flavour
 580       of preamble is emitted at each \n. */
 581    b->kind = kind;
 582
 583    ret = VG_(debugLog_vprintf) ( add_to__vmessage_buf,
 584                                  b, format, vargs );
 585
 586    /* If the message finished exactly with a \n, then flush it at this
 587       point.  If not, assume more bits of the same line will turn up
 588       in later messages, so don't bother to flush it right now. */
 589
 590    if (b->atLeft && b->buf_used > 0) {
 591       send_bytes_to_logging_sink( b->sink, b->buf, b->buf_used );
 592       b->buf_used = 0;
 593    }
 594
 595    return ret;
 596 }
 597
 598 /* Send a simple single-part message. */
 599 UInt VG_(message) ( VgMsgKind kind, const HChar* format, ... )
 600 {
 601    UInt count;
 602    va_list vargs;
 603    va_start(vargs,format);
 604    count = VG_(vmessage) ( kind, format, vargs );
 605    va_end(vargs);
 606    return count;
 607 }
 608
 609 static void revert_to_stderr ( void )
 610 {
 611    VG_(log_output_sink).fd = 2; /* stderr */
 612    VG_(log_output_sink).is_socket = False;
 613 }
 614
 615 /* VG_(message) variants with hardwired first argument. */
 616
 617 UInt VG_(fmsg) ( const HChar* format, ... )
 618 {
 619    UInt count;
 620    va_list vargs;
 621    va_start(vargs,format);
 622    count = VG_(vmessage) ( Vg_FailMsg, format, vargs );
 623    va_end(vargs);
 624    return count;
 625 }
 626
 627 void VG_(fmsg_bad_option) ( const HChar* opt, const HChar* format, ... )
 628 {
 629    va_list vargs;
 630    va_start(vargs,format);
 631    revert_to_stderr();
 632    VG_(message) (Vg_FailMsg, "Bad option: %s\n", opt);
 633    VG_(vmessage)(Vg_FailMsg, format, vargs );
 634    VG_(message) (Vg_FailMsg, "Use --help for more information or consult the user manual.\n");
 635    va_end(vargs);
 636    VG_(exit)(1);
 637 }
 638
 639 UInt VG_(umsg) ( const HChar* format, ... )
 640 {
 641    UInt count;
 642    va_list vargs;
 643    va_start(vargs,format);
 644    count = VG_(vmessage) ( Vg_UserMsg, format, vargs );
 645    va_end(vargs);
 646    return count;
 647 }
 648
 649 UInt VG_(dmsg) ( const HChar* format, ... )
 650 {
 651    UInt count;
 652    va_list vargs;
 653    va_start(vargs,format);
 654    count = VG_(vmessage) ( Vg_DebugMsg, format, vargs );
 655    va_end(vargs);
 656    return count;
 657 }
 658
 659 /* Flush any output that has accumulated in vmessage_buf as a
 660    result of previous calls to VG_(message) et al. */
 661 void VG_(message_flush) ( void )
 662 {
 663    vmessage_buf_t* b = &vmessage_buf;
 664    send_bytes_to_logging_sink( b->sink, b->buf, b->buf_used );
 665    b->buf_used = 0;
 666 }
 667
 668 __attribute__((noreturn))
 669 void VG_(err_missing_prog) ( void  )
 670 {
 671    revert_to_stderr();
 672    VG_(fmsg)("no program specified\n");
 673    VG_(fmsg)("Use --help for more information.\n");
 674    VG_(exit)(1);
 675 }
 676
 677 __attribute__((noreturn))
 678 void VG_(err_config_error) ( const HChar* format, ... )
 679 {
 680    va_list vargs;
 681    va_start(vargs,format);
 682    revert_to_stderr();
 683    VG_(message) (Vg_FailMsg, "Startup or configuration error:\n   ");
 684    VG_(vmessage)(Vg_FailMsg, format, vargs );
 685    VG_(message) (Vg_FailMsg, "Unable to start up properly.  Giving up.\n");
 686    va_end(vargs);
 687    VG_(exit)(1);
 688 }
 689
 690
 691 /*--------------------------------------------------------------------*/
 692 /*--- end                                                          ---*/
 693 /*--------------------------------------------------------------------*/