coregrind/m_libcassert.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Assertions and panics.                        m_libcassert.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2017 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, see <http://www.gnu.org/licenses/>.
  25
  26    The GNU General Public License is contained in the file COPYING.
  27 */
  28
  29 #include "pub_core_basics.h"
  30 #include "pub_core_vki.h"
  31 #include "pub_core_vkiscnums.h"
  32 #include "pub_core_threadstate.h"
  33 #include "pub_core_gdbserver.h"
  34 #include "pub_core_aspacemgr.h"
  35 #include "pub_core_libcbase.h"
  36 #include "pub_core_libcassert.h"
  37 #include "pub_core_libcprint.h"
  38 #include "pub_core_libcproc.h"      // For VG_(gettid)()
  39 #include "pub_core_machine.h"
  40 #include "pub_core_stacks.h"
  41 #include "pub_core_stacktrace.h"
  42 #include "pub_core_syscall.h"
  43 #include "pub_core_syswrap.h"
  44 #include "pub_core_tooliface.h"     // For VG_(details).{name,bug_reports_to}
  45 #include "pub_core_options.h"       // For VG_(clo_xml)
  46
  47 /* ---------------------------------------------------------------------
  48    Assertery.
  49    ------------------------------------------------------------------ */
  50
  51 #if defined(VGP_x86_linux) || defined(VGP_x86_darwin) \
  52     || defined(VGP_x86_solaris) || defined(VGP_x86_freebsd)
  53 #  define GET_STARTREGS(srP)                              \
  54       { UInt eip, esp, ebp;                               \
  55         __asm__ __volatile__(                             \
  56            "call 0f;"                                     \
  57            "0: popl %0;"                                  \
  58            "movl %%esp, %1;"                              \
  59            "movl %%ebp, %2;"                              \
  60            : "=r" (eip), "=r" (esp), "=r" (ebp)           \
  61            : /* reads none */                             \
  62            : "memory"                                     \
  63         );                                                \
  64         (srP)->r_pc = (ULong)eip;                         \
  65         (srP)->r_sp = (ULong)esp;                         \
  66         (srP)->misc.X86.r_ebp = ebp;                      \
  67       }
  68 #elif defined(VGP_amd64_linux) || defined(VGP_amd64_darwin) \
  69       || defined(VGP_amd64_solaris) || defined(VGP_amd64_freebsd)
  70 #  define GET_STARTREGS(srP)                              \
  71       { ULong rip, rsp, rbp;                              \
  72         __asm__ __volatile__(                             \
  73            "leaq 0(%%rip), %0;"                           \
  74            "movq %%rsp, %1;"                              \
  75            "movq %%rbp, %2;"                              \
  76            : "=r" (rip), "=r" (rsp), "=r" (rbp)           \
  77            : /* reads none */                             \
  78            : "memory"                                     \
  79         );                                                \
  80         (srP)->r_pc = rip;                                \
  81         (srP)->r_sp = rsp;                                \
  82         (srP)->misc.AMD64.r_rbp = rbp;                    \
  83       }
  84 #elif defined(VGP_ppc32_linux)
  85 #  define GET_STARTREGS(srP)                              \
  86       { UInt cia, r1, lr;                                 \
  87         __asm__ __volatile__(                             \
  88            "mflr 0;"                   /* r0 = lr */      \
  89            "bl 0f;"                    /* lr = pc */      \
  90            "0:\n"                                         \
  91            "mflr %0;"                  /* %0 = pc */      \
  92            "mtlr 0;"                   /* restore lr */   \
  93            "mr %1,1;"                  /* %1 = r1 */      \
  94            "mr %2,0;"                  /* %2 = lr */      \
  95            : "=r" (cia), "=r" (r1), "=r" (lr)             \
  96            : /* reads none */                             \
  97            : "r0" /* trashed */                           \
  98         );                                                \
  99         (srP)->r_pc = (ULong)cia;                         \
 100         (srP)->r_sp = (ULong)r1;                          \
 101         (srP)->misc.PPC32.r_lr = lr;                      \
 102       }
 103 #elif defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
 104 #  define GET_STARTREGS(srP)                              \
 105       { ULong cia, r1, lr;                                \
 106         __asm__ __volatile__(                             \
 107            "mflr 0;"                   /* r0 = lr */      \
 108            "bl 0f;"                    /* lr = pc */      \
 109            "0:\n"                                         \
 110            "mflr %0;"                  /* %0 = pc */      \
 111            "mtlr 0;"                   /* restore lr */   \
 112            "mr %1,1;"                  /* %1 = r1 */      \
 113            "mr %2,0;"                  /* %2 = lr */      \
 114            : "=r" (cia), "=r" (r1), "=r" (lr)             \
 115            : /* reads none */                             \
 116            : "r0" /* trashed */                           \
 117         );                                                \
 118         (srP)->r_pc = cia;                                \
 119         (srP)->r_sp = r1;                                 \
 120         (srP)->misc.PPC64.r_lr = lr;                      \
 121       }
 122 #elif defined(VGP_arm_linux)
 123 #  define GET_STARTREGS(srP)                              \
 124       { UInt block[6];                                    \
 125         __asm__ __volatile__(                             \
 126            "str r15, [%0, #+0];"                          \
 127            "str r14, [%0, #+4];"                          \
 128            "str r13, [%0, #+8];"                          \
 129            "str r12, [%0, #+12];"                         \
 130            "str r11, [%0, #+16];"                         \
 131            "str r7,  [%0, #+20];"                         \
 132            : /* out */                                    \
 133            : /* in */ "r"(&block[0])                      \
 134            : /* trash */ "memory"                         \
 135         );                                                \
 136         (srP)->r_pc = block[0] - 8;                       \
 137         (srP)->misc.ARM.r14 = block[1];                   \
 138         (srP)->r_sp = block[2];                           \
 139         (srP)->misc.ARM.r12 = block[3];                   \
 140         (srP)->misc.ARM.r11 = block[4];                   \
 141         (srP)->misc.ARM.r7  = block[5];                   \
 142       }
 143 #elif defined(VGP_arm64_linux) || defined(VGP_arm64_freebsd)
 144 #  define GET_STARTREGS(srP)                              \
 145       { ULong block[4];                                   \
 146         __asm__ __volatile__(                             \
 147            "adr x19, 0;"                                  \
 148            "str x19, [%0, #+0];"   /* pc */               \
 149            "mov x19, sp;"                                 \
 150            "str x19, [%0, #+8];"   /* sp */               \
 151            "str x29, [%0, #+16];"  /* fp */               \
 152            "str x30, [%0, #+24];"  /* lr */               \
 153            : /* out */                                    \
 154            : /* in */ "r"(&block[0])                      \
 155            : /* trash */ "memory","x19"                   \
 156         );                                                \
 157         (srP)->r_pc = block[0];                           \
 158         (srP)->r_sp = block[1];                           \
 159         (srP)->misc.ARM64.x29 = block[2];                 \
 160         (srP)->misc.ARM64.x30 = block[3];                 \
 161       }
 162 #elif defined(VGP_s390x_linux)
 163 #  define GET_STARTREGS(srP)                              \
 164       { ULong ia;                                         \
 165         ULong block[11];                                  \
 166         __asm__ __volatile__(                             \
 167            "bras %0, 0f;"                                 \
 168            "0: "                                          \
 169            "stg %%r15, 0(%1);"                            \
 170            "stg %%r11, 8(%1);"                            \
 171            "stg %%r14, 16(%1);"                           \
 172            "std %%f0, 24(%1);"                            \
 173            "std %%f1, 32(%1);"                            \
 174            "std %%f2, 40(%1);"                            \
 175            "std %%f3, 48(%1);"                            \
 176            "std %%f4, 56(%1);"                            \
 177            "std %%f5, 64(%1);"                            \
 178            "std %%f6, 72(%1);"                            \
 179            "std %%f7, 80(%1);"                            \
 180            : /* out */   "=r" (ia)                        \
 181            : /* in */    "a" (&block[0])                  \
 182            : /* trash */ "memory"                         \
 183         );                                                \
 184         (srP)->r_pc = ia;                                 \
 185         (srP)->r_sp = block[0];                           \
 186         (srP)->misc.S390X.r_fp = block[1];                \
 187         (srP)->misc.S390X.r_lr = block[2];                \
 188         (srP)->misc.S390X.r_f0 = block[3];                \
 189         (srP)->misc.S390X.r_f1 = block[4];                \
 190         (srP)->misc.S390X.r_f2 = block[5];                \
 191         (srP)->misc.S390X.r_f3 = block[6];                \
 192         (srP)->misc.S390X.r_f4 = block[7];                \
 193         (srP)->misc.S390X.r_f5 = block[8];                \
 194         (srP)->misc.S390X.r_f6 = block[9];                \
 195         (srP)->misc.S390X.r_f7 = block[10];               \
 196       }
 197 #elif defined(VGP_mips32_linux)
 198 #  define GET_STARTREGS(srP)                              \
 199       { UInt pc, sp, fp, ra, gp;                          \
 200       asm("move $8, $31;"             /* t0 = ra */       \
 201           "bal 0f;"                   /* ra = pc */       \
 202           "0:\n"                                          \
 203           "move %0, $31;"                                 \
 204           "move $31, $8;"             /* restore lr */    \
 205           "move %1, $29;"                                 \
 206           "move %2, $30;"                                 \
 207           "move %3, $31;"                                 \
 208           "move %4, $28;"                                 \
 209           : "=r" (pc),                                    \
 210             "=r" (sp),                                    \
 211             "=r" (fp),                                    \
 212             "=r" (ra),                                    \
 213             "=r" (gp)                                     \
 214           : /* reads none */                              \
 215           : "$8" /* trashed */ );                         \
 216         (srP)->r_pc = (ULong)pc - 8;                      \
 217         (srP)->r_sp = (ULong)sp;                          \
 218         (srP)->misc.MIPS32.r30 = (ULong)fp;               \
 219         (srP)->misc.MIPS32.r31 = (ULong)ra;               \
 220         (srP)->misc.MIPS32.r28 = (ULong)gp;               \
 221       }
 222 #elif defined(VGP_mips64_linux)
 223 #  define GET_STARTREGS(srP)                              \
 224       { ULong pc, sp, fp, ra, gp;                         \
 225       asm("move $8, $31;"             /* t0 = ra */       \
 226           "bal 0f;"                   /* ra = pc */       \
 227           "0:\n"                                          \
 228           "move %0, $31;"                                 \
 229           "move $31, $8;"             /* restore lr */    \
 230           "move %1, $29;"                                 \
 231           "move %2, $30;"                                 \
 232           "move %3, $31;"                                 \
 233           "move %4, $28;"                                 \
 234           : "=r" (pc),                                    \
 235             "=r" (sp),                                    \
 236             "=r" (fp),                                    \
 237             "=r" (ra),                                    \
 238             "=r" (gp)                                     \
 239           : /* reads none */                              \
 240           : "$8" /* trashed */ );                         \
 241         (srP)->r_pc = (ULong)pc - 8;                      \
 242         (srP)->r_sp = (ULong)sp;                          \
 243         (srP)->misc.MIPS64.r30 = (ULong)fp;               \
 244         (srP)->misc.MIPS64.r31 = (ULong)ra;               \
 245         (srP)->misc.MIPS64.r28 = (ULong)gp;               \
 246       }
 247 #elif defined(VGP_nanomips_linux)
 248 #  define GET_STARTREGS(srP)                              \
 249       { UInt pc=0, sp=0, fp=0, ra=0, gp=0;                \
 250       asm("addiupc[32] %0, -4          \n\t"              \
 251           "move %1, $sp                \n\t"              \
 252           "move %2, $fp                \n\t"              \
 253           "move %3, $ra                \n\t"              \
 254           "move %4, $gp                \n\t"              \
 255           : "=r" (pc),                                    \
 256             "=r" (sp),                                    \
 257             "=r" (fp),                                    \
 258             "=r" (ra),                                    \
 259             "=r" (gp)                                     \
 260           );                                              \
 261         (srP)->r_pc = (UInt)pc;                           \
 262         (srP)->r_sp = (UInt)sp;                           \
 263         (srP)->misc.MIPS32.r30 = (UInt)fp;                \
 264         (srP)->misc.MIPS32.r31 = (UInt)ra;                \
 265         (srP)->misc.MIPS32.r28 = (UInt)gp;                \
 266       }
 267 #else
 268 #  error Unknown platform
 269 #endif
 270
 271 #define BACKTRACE_DEPTH    100         // nice and deep!
 272
 273 __attribute__ ((__noreturn__))
 274 static void exit_wrk( Int status, Bool gdbserver_call_allowed)
 275 {
 276    static Bool exit_called = False;
 277    // avoid recursive exit during gdbserver call.
 278
 279    if (gdbserver_call_allowed && !exit_called) {
 280       const ThreadId atid = 1; // Arbitrary tid used to call/terminate gdbsrv.
 281       exit_called = True;
 282       if (status != 0
 283           && VgdbStopAtiS(VgdbStopAt_ValgrindAbExit, VG_(clo_vgdb_stop_at))) {
 284          if (VG_(gdbserver_init_done)()) {
 285             if (!(VG_(clo_launched_with_multi)))
 286                VG_(umsg)("(action at valgrind abnormal exit) vgdb me ... \n");
 287             VG_(gdbserver) (atid);
 288          } else {
 289             VG_(umsg)("(action at valgrind abnormal exit)\n"
 290                       "valgrind exit is too early => vgdb not yet usable\n");
 291          }
 292       }
 293       if (VG_(gdbserver_init_done)()) {
 294          // Always terminate the gdbserver when Valgrind exits, so as
 295          // to e.g. cleanup the FIFOs.
 296          VG_(gdbserver_exit) (atid,
 297                               status == 0 ? VgSrc_ExitProcess : VgSrc_FatalSig);
 298       }
 299    }
 300    exit_called = True;
 301
 302    VG_(exit_now) (status);
 303 }
 304
 305 /* Call the appropriate system call and nothing else. This function should
 306    be called in places where the dependencies of VG_(exit) need to be
 307    avoided. */
 308 __attribute__ ((__noreturn__))
 309 void VG_(exit_now)( Int status )
 310 {
 311 #if defined(VGO_linux)
 312    (void)VG_(do_syscall1)(__NR_exit_group, status );
 313 #elif defined(VGO_darwin) || defined(VGO_solaris) || defined(VGO_freebsd)
 314    (void)VG_(do_syscall1)(__NR_exit, status );
 315 #else
 316 #  error Unknown OS
 317 #endif
 318    /*NOTREACHED*/
 319    // We really shouldn't reach here.  Just in case we do, use some very crude
 320    // methods to force abort
 321    __builtin_trap();
 322    *(volatile Int*)0 = 'x';
 323 }
 324
 325 /* Pull down the entire world */
 326 void VG_(exit)( Int status )
 327 {
 328    exit_wrk (status, True);
 329 }
 330
 331 /* Pull down the entire world */
 332 void VG_(client_exit)( Int status )
 333 {
 334    exit_wrk (status, False);
 335 }
 336
 337 static void print_thread_state (Bool stack_usage,
 338                                 const HChar* prefix, ThreadId i)
 339 {
 340    VgStack *stack
 341       = (VgStack*)VG_(threads)[i].os_state.valgrind_stack_base;
 342    HChar syscallno[50];
 343    // must be large enough for VG_SYSNUM_STRING result + 10.
 344
 345    if (VG_(is_in_syscall) (i))
 346       VG_(sprintf)(syscallno, " syscall %s",
 347                    VG_SYSNUM_STRING(VG_(is_in_syscall_no)(i)));
 348    else
 349       syscallno[0] = 0;
 350    VG_(printf)("\n%sThread %u: status = %s%s (lwpid %d)\n", prefix, i,
 351                VG_(name_of_ThreadStatus)(VG_(threads)[i].status),
 352                syscallno,
 353                VG_(threads)[i].os_state.lwpid);
 354    if (VG_(threads)[i].status != VgTs_Empty)
 355       VG_(get_and_pp_StackTrace)( i, BACKTRACE_DEPTH );
 356    if (stack_usage && VG_(threads)[i].client_stack_highest_byte != 0 ) {
 357       Addr start, end;
 358
 359       start = end = 0;
 360       VG_(stack_limits)(VG_(get_SP)(i), &start, &end);
 361       if (start != end)
 362          VG_(printf)("%sclient stack range: [%p %p] client SP: %p\n",
 363                      prefix,
 364                      (void*)start, (void*)end, (void*)VG_(get_SP)(i));
 365       else
 366          VG_(printf)("%sclient stack range: ??????? client SP: %p\n",
 367                      prefix,
 368                      (void*)VG_(get_SP)(i));
 369    }
 370    if (stack_usage && stack != 0) {
 371       Addr stack_low_addr = VG_(am_valgrind_stack_low_addr) (stack);
 372
 373       VG_(printf)
 374          ("%svalgrind stack range: [%p %p] top usage: %lu of %lu\n",
 375           prefix,
 376           (void*)stack_low_addr,
 377           (void*)(stack_low_addr + VG_(clo_valgrind_stacksize) - 1),
 378           VG_(clo_valgrind_stacksize)
 379           - VG_(am_get_VgStack_unused_szB) (stack,
 380                                             VG_(clo_valgrind_stacksize)),
 381           (SizeT) VG_(clo_valgrind_stacksize));
 382    }
 383 }
 384
 385 // Print the scheduler status.
 386 static void show_sched_status_wrk ( Bool host_stacktrace,
 387                                     Bool stack_usage,
 388                                     Bool exited_threads,
 389                                     const UnwindStartRegs* startRegsIN)
 390 {
 391    Int i;
 392    if (host_stacktrace) {
 393       const Bool save_clo_xml = VG_(clo_xml);
 394       Addr stacktop;
 395       Addr ips[BACKTRACE_DEPTH];
 396       Int  n_ips;
 397       ThreadState *tst
 398          = VG_(get_ThreadState)( VG_(lwpid_to_vgtid_dead_ok)(VG_(gettid)()));
 399
 400       // If necessary, fake up an ExeContext which is of our actual real CPU
 401       // state.  Could cause problems if we got the panic/exception within the
 402       // execontext/stack dump/symtab code.  But it's better than nothing.
 403       UnwindStartRegs startRegs;
 404       VG_(memset)(&startRegs, 0, sizeof(startRegs));
 405
 406       if (startRegsIN == NULL) {
 407          GET_STARTREGS(&startRegs);
 408       } else {
 409          startRegs = *startRegsIN;
 410       }
 411
 412       stacktop = tst->os_state.valgrind_stack_init_SP;
 413
 414       n_ips =
 415          VG_(get_StackTrace_wrk)(
 416             0/*tid is unknown*/,
 417             ips, BACKTRACE_DEPTH,
 418             NULL/*array to dump SP values in*/,
 419             NULL/*array to dump FP values in*/,
 420             &startRegs, stacktop
 421          );
 422       VG_(printf)("\nhost stacktrace:\n");
 423       VG_(clo_xml) = False;
 424       VG_(pp_StackTrace) (VG_(current_DiEpoch)(), ips, n_ips);
 425       VG_(clo_xml) = save_clo_xml;
 426    }
 427
 428    VG_(printf)("\nsched status:\n");
 429    if (VG_(threads) == NULL) {
 430       VG_(printf)("  scheduler not yet initialised\n");
 431    } else {
 432       VG_(printf)("  running_tid=%u\n", VG_(get_running_tid)());
 433       for (i = 1; i < VG_N_THREADS; i++) {
 434          VgStack *stack
 435             = (VgStack*)VG_(threads)[i].os_state.valgrind_stack_base;
 436          /* If a thread slot was never used (yet), valgrind_stack_base is 0.
 437             If a thread slot is used by a thread or was used by a thread which
 438             has exited, then valgrind_stack_base points to the stack base. */
 439          if (VG_(threads)[i].status == VgTs_Empty
 440              && (!exited_threads || stack == 0)) continue;
 441          print_thread_state(stack_usage, "", i);
 442          if (VG_(inner_threads) != NULL) {
 443             /* An inner V has informed us (the outer) of its thread array.
 444                Report the inner guest stack trace. */
 445             UInt inner_tid;
 446
 447             for (inner_tid = 1; inner_tid < VG_N_THREADS; inner_tid++) {
 448                if (VG_(threads)[i].os_state.lwpid
 449                    == VG_(inner_threads)[inner_tid].os_state.lwpid) {
 450                   ThreadState* save_outer_vg_threads = VG_(threads);
 451
 452                   VG_(threads) = VG_(inner_threads);
 453                   print_thread_state(stack_usage, "INNER ", inner_tid);
 454                   VG_(threads) = save_outer_vg_threads;
 455                   break;
 456                }
 457             }
 458          }
 459       }
 460    }
 461    VG_(printf)("\n");
 462 }
 463
 464 void VG_(show_sched_status) ( Bool host_stacktrace,
 465                               Bool stack_usage,
 466                               Bool exited_threads)
 467 {
 468    show_sched_status_wrk (host_stacktrace,
 469                           stack_usage,
 470                           exited_threads,
 471                           NULL);
 472 }
 473
 474 __attribute__ ((noreturn))
 475 static void report_and_quit ( const HChar* report,
 476                               const UnwindStartRegs* startRegsIN )
 477 {
 478    show_sched_status_wrk (True,  // host_stacktrace
 479                           True,  // stack_usage
 480                           False, // exited_threads
 481                           startRegsIN);
 482    VG_(printf)(
 483       "\n"
 484       "Note: see also the FAQ in the source distribution.\n"
 485       "It contains workarounds to several common problems.\n"
 486       "In particular, if Valgrind aborted or crashed after\n"
 487       "identifying problems in your program, there's a good chance\n"
 488       "that fixing those problems will prevent Valgrind aborting or\n"
 489       "crashing, especially if it happened in m_mallocfree.c.\n"
 490       "\n"
 491       "If that doesn't help, please report this bug to: %s\n\n"
 492       "In the bug report, send all the above text, the valgrind\n"
 493       "version, and what OS and version you are using.  Thanks.\n\n",
 494       report);
 495    VG_(exit)(1);
 496 }
 497
 498 void VG_(assert_fail) ( Bool isCore, const HChar* expr, const HChar* file,
 499                         Int line, const HChar* fn, const HChar* format, ... )
 500 {
 501    va_list vargs, vargs_copy;
 502    const HChar* component;
 503    const HChar* bugs_to;
 504    UInt written;
 505
 506    static Bool entered = False;
 507    if (entered)
 508       VG_(exit)(2);
 509    entered = True;
 510
 511    if (isCore) {
 512       component = "valgrind";
 513       bugs_to   = VG_BUGS_TO;
 514    } else {
 515       component = VG_(details).name;
 516       bugs_to   = VG_(details).bug_reports_to;
 517    }
 518
 519    if (VG_(clo_xml))
 520       VG_(printf_xml)("</valgrindoutput>\n");
 521
 522    // Treat vg_assert2(0, "foo") specially, as a panicky abort
 523    if (VG_STREQ(expr, "0")) {
 524       VG_(printf)("\n%s: %s:%d (%s): the 'impossible' happened.\n",
 525                   component, file, line, fn );
 526    } else {
 527       VG_(printf)("\n%s: %s:%d (%s): Assertion '%s' failed.\n",
 528                   component, file, line, fn, expr );
 529    }
 530
 531    /* Check whether anything will be written */
 532    HChar buf[5];
 533    va_start(vargs, format);
 534    va_copy(vargs_copy, vargs);
 535    written = VG_(vsnprintf) ( buf, sizeof(buf), format, vargs );
 536    va_end(vargs);
 537
 538    if (written > 0) {
 539       VG_(printf)("%s: ", component);
 540       VG_(vprintf)(format, vargs_copy);
 541       VG_(printf)("\n");
 542    }
 543
 544    report_and_quit(bugs_to, NULL);
 545 }
 546
 547 __attribute__ ((noreturn))
 548 static void panic ( const HChar* name, const HChar* report, const HChar* str,
 549                     const UnwindStartRegs* startRegs )
 550 {
 551    if (VG_(clo_xml))
 552       VG_(printf_xml)("</valgrindoutput>\n");
 553    VG_(printf)("\n%s: the 'impossible' happened:\n   %s\n", name, str);
 554    report_and_quit(report, startRegs);
 555 }
 556
 557 void VG_(core_panic_at) ( const HChar* str, const UnwindStartRegs* startRegs )
 558 {
 559    panic("valgrind", VG_BUGS_TO, str, startRegs);
 560 }
 561
 562 void VG_(core_panic) ( const HChar* str )
 563 {
 564    VG_(core_panic_at)(str, NULL);
 565 }
 566
 567 void VG_(tool_panic) ( const HChar* str )
 568 {
 569    panic(VG_(details).name, VG_(details).bug_reports_to, str, NULL);
 570 }
 571
 572 /* Print some helpful-ish text about unimplemented things, and give up. */
 573 void VG_(unimplemented) ( const HChar* format, ... )
 574 {
 575    va_list vargs;
 576    HChar msg[256];
 577
 578    va_start(vargs, format);
 579    VG_(vsnprintf)(msg, sizeof(msg), format, vargs);
 580    va_end(vargs);
 581
 582    if (VG_(clo_xml))
 583       VG_(printf_xml)("</valgrindoutput>\n");
 584    VG_(umsg)("\n");
 585    VG_(umsg)("Valgrind detected that your program requires\n");
 586    VG_(umsg)("the following unimplemented functionality:\n");
 587    VG_(umsg)("   %s\n", msg);
 588    VG_(umsg)("This may be because the functionality is hard to implement,\n");
 589    VG_(umsg)("or because no reasonable program would behave this way,\n");
 590    VG_(umsg)("or because nobody has yet needed it.  "
 591              "In any case, let us know at\n");
 592    VG_(umsg)("%s and/or try to work around the problem, if you can.\n",
 593              VG_BUGS_TO);
 594    VG_(umsg)("\n");
 595    VG_(umsg)("Valgrind has to exit now.  Sorry.  Bye!\n");
 596    VG_(umsg)("\n");
 597    VG_(show_sched_status)(False,  // host_stacktrace
 598                           False,  // stack_usage
 599                           False); // exited_threads
 600    VG_(exit)(1);
 601 }
 602
 603 /*--------------------------------------------------------------------*/
 604 /*--- end                                                          ---*/
 605 /*--------------------------------------------------------------------*/