base/debug/stack_trace_posix.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/debug/stack_trace.h"
   6
   7 #include <errno.h>
   8 #include <execinfo.h>
   9 #include <fcntl.h>
  10 #include <signal.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <sys/param.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <unistd.h>
  17
  18 #include <ostream>
  19
  20 #if defined(__GLIBCXX__)
  21 #include <cxxabi.h>
  22 #endif
  23
  24 #if defined(OS_MACOSX)
  25 #include <AvailabilityMacros.h>
  26 #endif
  27
  28 #include "base/basictypes.h"
  29 #include "base/debug/debugger.h"
  30 #include "base/logging.h"
  31 #include "base/memory/scoped_ptr.h"
  32 #include "base/posix/eintr_wrapper.h"
  33 #include "base/strings/string_number_conversions.h"
  34
  35 #if defined(USE_SYMBOLIZE)
  36 #include "base/third_party/symbolize/symbolize.h"
  37 #endif
  38
  39 namespace base {
  40 namespace debug {
  41
  42 namespace {
  43
  44 volatile sig_atomic_t in_signal_handler = 0;
  45
  46 #if !defined(USE_SYMBOLIZE) && defined(__GLIBCXX__)
  47 // The prefix used for mangled symbols, per the Itanium C++ ABI:
  48 // http://www.codesourcery.com/cxx-abi/abi.html#mangling
  49 const char kMangledSymbolPrefix[] = "_Z";
  50
  51 // Characters that can be used for symbols, generated by Ruby:
  52 // (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
  53 const char kSymbolCharacters[] =
  54     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
  55 #endif  // !defined(USE_SYMBOLIZE) && defined(__GLIBCXX__)
  56
  57 #if !defined(USE_SYMBOLIZE)
  58 // Demangles C++ symbols in the given text. Example:
  59 //
  60 // "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
  61 // =>
  62 // "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
  63 void DemangleSymbols(std::string* text) {
  64   // Note: code in this function is NOT async-signal safe (std::string uses
  65   // malloc internally).
  66
  67 #if defined(__GLIBCXX__)
  68
  69   std::string::size_type search_from = 0;
  70   while (search_from < text->size()) {
  71     // Look for the start of a mangled symbol, from search_from.
  72     std::string::size_type mangled_start =
  73         text->find(kMangledSymbolPrefix, search_from);
  74     if (mangled_start == std::string::npos) {
  75       break;  // Mangled symbol not found.
  76     }
  77
  78     // Look for the end of the mangled symbol.
  79     std::string::size_type mangled_end =
  80         text->find_first_not_of(kSymbolCharacters, mangled_start);
  81     if (mangled_end == std::string::npos) {
  82       mangled_end = text->size();
  83     }
  84     std::string mangled_symbol =
  85         text->substr(mangled_start, mangled_end - mangled_start);
  86
  87     // Try to demangle the mangled symbol candidate.
  88     int status = 0;
  89     scoped_ptr_malloc<char> demangled_symbol(
  90         abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
  91     if (status == 0) {  // Demangling is successful.
  92       // Remove the mangled symbol.
  93       text->erase(mangled_start, mangled_end - mangled_start);
  94       // Insert the demangled symbol.
  95       text->insert(mangled_start, demangled_symbol.get());
  96       // Next time, we'll start right after the demangled symbol we inserted.
  97       search_from = mangled_start + strlen(demangled_symbol.get());
  98     } else {
  99       // Failed to demangle.  Retry after the "_Z" we just found.
 100       search_from = mangled_start + 2;
 101     }
 102   }
 103
 104 #endif  // defined(__GLIBCXX__)
 105 }
 106 #endif  // !defined(USE_SYMBOLIZE)
 107
 108 class BacktraceOutputHandler {
 109  public:
 110   virtual void HandleOutput(const char* output) = 0;
 111
 112  protected:
 113   virtual ~BacktraceOutputHandler() {}
 114 };
 115
 116 void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
 117   char buf[1024] = { '\0' };
 118   handler->HandleOutput(" [0x");
 119   internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
 120                    buf, sizeof(buf), 16, 12);
 121   handler->HandleOutput(buf);
 122   handler->HandleOutput("]");
 123 }
 124
 125 void ProcessBacktrace(void *const *trace,
 126                       int size,
 127                       BacktraceOutputHandler* handler) {
 128   // NOTE: This code MUST be async-signal safe (it's used by in-process
 129   // stack dumping signal handler). NO malloc or stdio is allowed here.
 130
 131 #if defined(USE_SYMBOLIZE)
 132   for (int i = 0; i < size; ++i) {
 133     OutputPointer(trace[i], handler);
 134     handler->HandleOutput(" ");
 135
 136     char buf[1024] = { '\0' };
 137
 138     // Subtract by one as return address of function may be in the next
 139     // function when a function is annotated as noreturn.
 140     void* address = static_cast<char*>(trace[i]) - 1;
 141     if (google::Symbolize(address, buf, sizeof(buf)))
 142       handler->HandleOutput(buf);
 143     else
 144       handler->HandleOutput("<unknown>");
 145
 146     handler->HandleOutput("\n");
 147   }
 148 #else
 149   bool printed = false;
 150
 151   // Below part is async-signal unsafe (uses malloc), so execute it only
 152   // when we are not executing the signal handler.
 153   if (in_signal_handler == 0) {
 154     scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
 155     if (trace_symbols.get()) {
 156       for (int i = 0; i < size; ++i) {
 157         std::string trace_symbol = trace_symbols.get()[i];
 158         DemangleSymbols(&trace_symbol);
 159         handler->HandleOutput(trace_symbol.c_str());
 160         handler->HandleOutput("\n");
 161       }
 162
 163       printed = true;
 164     }
 165   }
 166
 167   if (!printed) {
 168     for (int i = 0; i < size; ++i) {
 169       OutputPointer(trace[i], handler);
 170       handler->HandleOutput("\n");
 171     }
 172   }
 173 #endif  // defined(USE_SYMBOLIZE)
 174 }
 175
 176 void PrintToStderr(const char* output) {
 177   // NOTE: This code MUST be async-signal safe (it's used by in-process
 178   // stack dumping signal handler). NO malloc or stdio is allowed here.
 179   ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
 180 }
 181
 182 #if !defined(OS_IOS)
 183 void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
 184   // NOTE: This code MUST be async-signal safe.
 185   // NO malloc or stdio is allowed here.
 186
 187   // Record the fact that we are in the signal handler now, so that the rest
 188   // of StackTrace can behave in an async-signal-safe manner.
 189   in_signal_handler = 1;
 190
 191   if (BeingDebugged())
 192     BreakDebugger();
 193
 194   PrintToStderr("Received signal ");
 195   char buf[1024] = { 0 };
 196   internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
 197   PrintToStderr(buf);
 198   if (signal == SIGBUS) {
 199     if (info->si_code == BUS_ADRALN)
 200       PrintToStderr(" BUS_ADRALN ");
 201     else if (info->si_code == BUS_ADRERR)
 202       PrintToStderr(" BUS_ADRERR ");
 203     else if (info->si_code == BUS_OBJERR)
 204       PrintToStderr(" BUS_OBJERR ");
 205     else
 206       PrintToStderr(" <unknown> ");
 207   } else if (signal == SIGFPE) {
 208     if (info->si_code == FPE_FLTDIV)
 209       PrintToStderr(" FPE_FLTDIV ");
 210     else if (info->si_code == FPE_FLTINV)
 211       PrintToStderr(" FPE_FLTINV ");
 212     else if (info->si_code == FPE_FLTOVF)
 213       PrintToStderr(" FPE_FLTOVF ");
 214     else if (info->si_code == FPE_FLTRES)
 215       PrintToStderr(" FPE_FLTRES ");
 216     else if (info->si_code == FPE_FLTSUB)
 217       PrintToStderr(" FPE_FLTSUB ");
 218     else if (info->si_code == FPE_FLTUND)
 219       PrintToStderr(" FPE_FLTUND ");
 220     else if (info->si_code == FPE_INTDIV)
 221       PrintToStderr(" FPE_INTDIV ");
 222     else if (info->si_code == FPE_INTOVF)
 223       PrintToStderr(" FPE_INTOVF ");
 224     else
 225       PrintToStderr(" <unknown> ");
 226   } else if (signal == SIGILL) {
 227     if (info->si_code == ILL_BADSTK)
 228       PrintToStderr(" ILL_BADSTK ");
 229     else if (info->si_code == ILL_COPROC)
 230       PrintToStderr(" ILL_COPROC ");
 231     else if (info->si_code == ILL_ILLOPN)
 232       PrintToStderr(" ILL_ILLOPN ");
 233     else if (info->si_code == ILL_ILLADR)
 234       PrintToStderr(" ILL_ILLADR ");
 235     else if (info->si_code == ILL_ILLTRP)
 236       PrintToStderr(" ILL_ILLTRP ");
 237     else if (info->si_code == ILL_PRVOPC)
 238       PrintToStderr(" ILL_PRVOPC ");
 239     else if (info->si_code == ILL_PRVREG)
 240       PrintToStderr(" ILL_PRVREG ");
 241     else
 242       PrintToStderr(" <unknown> ");
 243   } else if (signal == SIGSEGV) {
 244     if (info->si_code == SEGV_MAPERR)
 245       PrintToStderr(" SEGV_MAPERR ");
 246     else if (info->si_code == SEGV_ACCERR)
 247       PrintToStderr(" SEGV_ACCERR ");
 248     else
 249       PrintToStderr(" <unknown> ");
 250   }
 251   if (signal == SIGBUS || signal == SIGFPE ||
 252       signal == SIGILL || signal == SIGSEGV) {
 253     internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
 254                      buf, sizeof(buf), 16, 12);
 255     PrintToStderr(buf);
 256   }
 257   PrintToStderr("\n");
 258
 259   debug::StackTrace().Print();
 260
 261 #if defined(OS_LINUX)
 262 #if ARCH_CPU_X86_FAMILY
 263   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
 264   const struct {
 265     const char* label;
 266     greg_t value;
 267   } registers[] = {
 268 #if ARCH_CPU_32_BITS
 269     { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
 270     { "  fs: ", context->uc_mcontext.gregs[REG_FS] },
 271     { "  es: ", context->uc_mcontext.gregs[REG_ES] },
 272     { "  ds: ", context->uc_mcontext.gregs[REG_DS] },
 273     { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
 274     { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
 275     { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
 276     { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
 277     { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
 278     { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
 279     { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
 280     { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
 281     { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
 282     { " err: ", context->uc_mcontext.gregs[REG_ERR] },
 283     { "  ip: ", context->uc_mcontext.gregs[REG_EIP] },
 284     { "  cs: ", context->uc_mcontext.gregs[REG_CS] },
 285     { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
 286     { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
 287     { "  ss: ", context->uc_mcontext.gregs[REG_SS] },
 288 #elif ARCH_CPU_64_BITS
 289     { "  r8: ", context->uc_mcontext.gregs[REG_R8] },
 290     { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
 291     { " r10: ", context->uc_mcontext.gregs[REG_R10] },
 292     { " r11: ", context->uc_mcontext.gregs[REG_R11] },
 293     { " r12: ", context->uc_mcontext.gregs[REG_R12] },
 294     { " r13: ", context->uc_mcontext.gregs[REG_R13] },
 295     { " r14: ", context->uc_mcontext.gregs[REG_R14] },
 296     { " r15: ", context->uc_mcontext.gregs[REG_R15] },
 297     { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
 298     { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
 299     { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
 300     { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
 301     { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
 302     { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
 303     { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
 304     { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
 305     { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
 306     { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
 307     { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
 308     { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
 309     { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
 310     { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
 311     { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
 312 #endif
 313   };
 314
 315 #if ARCH_CPU_32_BITS
 316   const int kRegisterPadding = 8;
 317 #elif ARCH_CPU_64_BITS
 318   const int kRegisterPadding = 16;
 319 #endif
 320
 321   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(registers); i++) {
 322     PrintToStderr(registers[i].label);
 323     internal::itoa_r(registers[i].value, buf, sizeof(buf),
 324                      16, kRegisterPadding);
 325     PrintToStderr(buf);
 326
 327     if ((i + 1) % 4 == 0)
 328       PrintToStderr("\n");
 329   }
 330   PrintToStderr("\n");
 331 #endif
 332 #elif defined(OS_MACOSX)
 333   // TODO(shess): Port to 64-bit.
 334 #if ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS
 335   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
 336   size_t len;
 337
 338   // NOTE: Even |snprintf()| is not on the approved list for signal
 339   // handlers, but buffered I/O is definitely not on the list due to
 340   // potential for |malloc()|.
 341   len = static_cast<size_t>(
 342       snprintf(buf, sizeof(buf),
 343                "ax: %x, bx: %x, cx: %x, dx: %x\n",
 344                context->uc_mcontext->__ss.__eax,
 345                context->uc_mcontext->__ss.__ebx,
 346                context->uc_mcontext->__ss.__ecx,
 347                context->uc_mcontext->__ss.__edx));
 348   write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
 349
 350   len = static_cast<size_t>(
 351       snprintf(buf, sizeof(buf),
 352                "di: %x, si: %x, bp: %x, sp: %x, ss: %x, flags: %x\n",
 353                context->uc_mcontext->__ss.__edi,
 354                context->uc_mcontext->__ss.__esi,
 355                context->uc_mcontext->__ss.__ebp,
 356                context->uc_mcontext->__ss.__esp,
 357                context->uc_mcontext->__ss.__ss,
 358                context->uc_mcontext->__ss.__eflags));
 359   write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
 360
 361   len = static_cast<size_t>(
 362       snprintf(buf, sizeof(buf),
 363                "ip: %x, cs: %x, ds: %x, es: %x, fs: %x, gs: %x\n",
 364                context->uc_mcontext->__ss.__eip,
 365                context->uc_mcontext->__ss.__cs,
 366                context->uc_mcontext->__ss.__ds,
 367                context->uc_mcontext->__ss.__es,
 368                context->uc_mcontext->__ss.__fs,
 369                context->uc_mcontext->__ss.__gs));
 370   write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
 371 #endif  // ARCH_CPU_32_BITS
 372 #endif  // defined(OS_MACOSX)
 373   _exit(1);
 374 }
 375 #endif  // !defined(OS_IOS)
 376
 377 class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
 378  public:
 379   PrintBacktraceOutputHandler() {}
 380
 381   virtual void HandleOutput(const char* output) OVERRIDE {
 382     // NOTE: This code MUST be async-signal safe (it's used by in-process
 383     // stack dumping signal handler). NO malloc or stdio is allowed here.
 384     PrintToStderr(output);
 385   }
 386
 387  private:
 388   DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
 389 };
 390
 391 class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
 392  public:
 393   explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
 394   }
 395
 396   virtual void HandleOutput(const char* output) OVERRIDE {
 397     (*os_) << output;
 398   }
 399
 400  private:
 401   std::ostream* os_;
 402
 403   DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
 404 };
 405
 406 #if !defined(OS_IOS)
 407 void WarmUpBacktrace() {
 408   // Warm up stack trace infrastructure. It turns out that on the first
 409   // call glibc initializes some internal data structures using pthread_once,
 410   // and even backtrace() can call malloc(), leading to hangs.
 411   //
 412   // Example stack trace snippet (with tcmalloc):
 413   //
 414   // #8  0x0000000000a173b5 in tc_malloc
 415   //             at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
 416   // #9  0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
 417   // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
 418   // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
 419   // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
 420   //             at dl-open.c:639
 421   // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
 422   // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
 423   // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
 424   // #16 __GI___libc_dlopen_mode at dl-libc.c:165
 425   // #17 0x00007ffff61ef8f5 in init
 426   //             at ../sysdeps/x86_64/../ia64/backtrace.c:53
 427   // #18 0x00007ffff6aad400 in pthread_once
 428   //             at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
 429   // #19 0x00007ffff61efa14 in __GI___backtrace
 430   //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
 431   // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
 432   //             at base/debug/stack_trace_posix.cc:175
 433   // #21 0x00000000007a4ae5 in
 434   //             base::(anonymous namespace)::StackDumpSignalHandler
 435   //             at base/process_util_posix.cc:172
 436   // #22 <signal handler called>
 437   StackTrace stack_trace;
 438 }
 439 #endif  // !defined(OS_IOS)
 440
 441 }  // namespace
 442
 443 #if !defined(OS_IOS)
 444 bool EnableInProcessStackDumping() {
 445   // When running in an application, our code typically expects SIGPIPE
 446   // to be ignored.  Therefore, when testing that same code, it should run
 447   // with SIGPIPE ignored as well.
 448   struct sigaction sigpipe_action;
 449   memset(&sigpipe_action, 0, sizeof(sigpipe_action));
 450   sigpipe_action.sa_handler = SIG_IGN;
 451   sigemptyset(&sigpipe_action.sa_mask);
 452   bool success = (sigaction(SIGPIPE, &sigpipe_action, NULL) == 0);
 453
 454   // Avoid hangs during backtrace initialization, see above.
 455   WarmUpBacktrace();
 456
 457   struct sigaction action;
 458   memset(&action, 0, sizeof(action));
 459   action.sa_flags = SA_RESETHAND | SA_SIGINFO;
 460   action.sa_sigaction = &StackDumpSignalHandler;
 461   sigemptyset(&action.sa_mask);
 462
 463   success &= (sigaction(SIGILL, &action, NULL) == 0);
 464   success &= (sigaction(SIGABRT, &action, NULL) == 0);
 465   success &= (sigaction(SIGFPE, &action, NULL) == 0);
 466   success &= (sigaction(SIGBUS, &action, NULL) == 0);
 467   success &= (sigaction(SIGSEGV, &action, NULL) == 0);
 468   success &= (sigaction(SIGSYS, &action, NULL) == 0);
 469
 470   return success;
 471 }
 472 #endif  // !defined(OS_IOS)
 473
 474 StackTrace::StackTrace() {
 475   // NOTE: This code MUST be async-signal safe (it's used by in-process
 476   // stack dumping signal handler). NO malloc or stdio is allowed here.
 477
 478   // Though the backtrace API man page does not list any possible negative
 479   // return values, we take no chance.
 480   count_ = std::max(backtrace(trace_, arraysize(trace_)), 0);
 481 }
 482
 483 void StackTrace::Print() const {
 484   // NOTE: This code MUST be async-signal safe (it's used by in-process
 485   // stack dumping signal handler). NO malloc or stdio is allowed here.
 486
 487   PrintBacktraceOutputHandler handler;
 488   ProcessBacktrace(trace_, count_, &handler);
 489 }
 490
 491 void StackTrace::OutputToStream(std::ostream* os) const {
 492   StreamBacktraceOutputHandler handler(os);
 493   ProcessBacktrace(trace_, count_, &handler);
 494 }
 495
 496 namespace internal {
 497
 498 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
 499 char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
 500   // Make sure we can write at least one NUL byte.
 501   size_t n = 1;
 502   if (n > sz)
 503     return NULL;
 504
 505   if (base < 2 || base > 16) {
 506     buf[0] = '\000';
 507     return NULL;
 508   }
 509
 510   char *start = buf;
 511
 512   uintptr_t j = i;
 513
 514   // Handle negative numbers (only for base 10).
 515   if (i < 0 && base == 10) {
 516     j = -i;
 517
 518     // Make sure we can write the '-' character.
 519     if (++n > sz) {
 520       buf[0] = '\000';
 521       return NULL;
 522     }
 523     *start++ = '-';
 524   }
 525
 526   // Loop until we have converted the entire number. Output at least one
 527   // character (i.e. '0').
 528   char *ptr = start;
 529   do {
 530     // Make sure there is still enough space left in our output buffer.
 531     if (++n > sz) {
 532       buf[0] = '\000';
 533       return NULL;
 534     }
 535
 536     // Output the next digit.
 537     *ptr++ = "0123456789abcdef"[j % base];
 538     j /= base;
 539
 540     if (padding > 0)
 541       padding--;
 542   } while (j > 0 || padding > 0);
 543
 544   // Terminate the output with a NUL character.
 545   *ptr = '\000';
 546
 547   // Conversion to ASCII actually resulted in the digits being in reverse
 548   // order. We can't easily generate them in forward order, as we can't tell
 549   // the number of characters needed until we are done converting.
 550   // So, now, we reverse the string (except for the possible "-" sign).
 551   while (--ptr > start) {
 552     char ch = *ptr;
 553     *ptr = *start;
 554     *start++ = ch;
 555   }
 556   return buf;
 557 }
 558
 559 }  // namespace internal
 560
 561 }  // namespace debug
 562 }  // namespace base