output.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2011,2012,2013,2014 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2010 Joe Damato
   5  * Copyright (C) 1997,1998,1999,2001,2002,2003,2004,2007,2008,2009 Juan Cespedes
   6  * Copyright (C) 2006 Paul Gilliam, IBM Corporation
   7  * Copyright (C) 2006 Ian Wienand
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22  * 02110-1301 USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <string.h>
  31 #include <time.h>
  32 #include <sys/time.h>
  33 #include <unistd.h>
  34 #include <errno.h>
  35 #include <assert.h>
  36 #include <inttypes.h>
  37
  38 #include "output.h"
  39 #include "demangle.h"
  40 #include "fetch.h"
  41 #include "lens_default.h"
  42 #include "library.h"
  43 #include "memstream.h"
  44 #include "options.h"
  45 #include "param.h"
  46 #include "proc.h"
  47 #include "prototype.h"
  48 #include "summary.h"
  49 #include "type.h"
  50 #include "value.h"
  51 #include "value_dict.h"
  52
  53 static struct process *current_proc = NULL;
  54 static size_t current_depth = 0;
  55 static int current_column = 0;
  56
  57 static void
  58 output_indent(struct process *proc)
  59 {
  60         int d = options.indent * (proc->callstack_depth - 1);
  61         current_column += fprintf(options.output, "%*s", d, "");
  62 }
  63
  64 static void
  65 begin_of_line(struct process *proc, int is_func, int indent)
  66 {
  67         current_column = 0;
  68         if (!proc) {
  69                 return;
  70         }
  71         if ((options.output != stderr) && (opt_p || options.follow)) {
  72                 current_column += fprintf(options.output, "%u ", proc->pid);
  73         } else if (options.follow) {
  74                 current_column += fprintf(options.output, "[pid %u] ", proc->pid);
  75         }
  76         if (opt_r) {
  77                 struct timeval tv;
  78                 static struct timeval old_tv = { 0, 0 };
  79                 struct timeval diff;
  80
  81                 gettimeofday(&tv, NULL);
  82
  83                 if (old_tv.tv_sec == 0 && old_tv.tv_usec == 0) {
  84                         old_tv.tv_sec = tv.tv_sec;
  85                         old_tv.tv_usec = tv.tv_usec;
  86                 }
  87                 diff.tv_sec = tv.tv_sec - old_tv.tv_sec;
  88                 if (tv.tv_usec >= old_tv.tv_usec) {
  89                         diff.tv_usec = tv.tv_usec - old_tv.tv_usec;
  90                 } else {
  91                         diff.tv_sec--;
  92                         diff.tv_usec = 1000000 + tv.tv_usec - old_tv.tv_usec;
  93                 }
  94                 old_tv.tv_sec = tv.tv_sec;
  95                 old_tv.tv_usec = tv.tv_usec;
  96                 current_column += fprintf(options.output, "%3lu.%06d ",
  97                                           (unsigned long)diff.tv_sec,
  98                                           (int)diff.tv_usec);
  99         }
 100         if (opt_t) {
 101                 struct timeval tv;
 102                 gettimeofday(&tv, NULL);
 103                 if (opt_t > 2) {
 104                         current_column += fprintf(options.output, "%lu.%06d ",
 105                                                   (unsigned long)tv.tv_sec,
 106                                                   (int)tv.tv_usec);
 107                 } else if (opt_t > 1) {
 108                         struct tm *tmp = localtime(&tv.tv_sec);
 109                         current_column +=
 110                             fprintf(options.output, "%02d:%02d:%02d.%06d ",
 111                                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
 112                                     (int)tv.tv_usec);
 113                 } else {
 114                         struct tm *tmp = localtime(&tv.tv_sec);
 115                         current_column += fprintf(options.output, "%02d:%02d:%02d ",
 116                                                   tmp->tm_hour, tmp->tm_min,
 117                                                   tmp->tm_sec);
 118                 }
 119         }
 120         if (opt_i) {
 121                 if (is_func) {
 122                         struct callstack_element *stel
 123                                 = &proc->callstack[proc->callstack_depth - 1];
 124                         current_column += fprintf(options.output, "[%p] ",
 125                                                   stel->return_addr);
 126                 } else {
 127                         current_column += fprintf(options.output, "[%p] ",
 128                                                   proc->instruction_pointer);
 129                 }
 130         }
 131         if (options.indent > 0 && indent) {
 132                 output_indent(proc);
 133         }
 134 }
 135
 136 static struct arg_type_info *
 137 get_unknown_type(void)
 138 {
 139         static struct arg_type_info *ret = NULL;
 140         if (ret != NULL)
 141                 return ret;
 142
 143         static struct arg_type_info info;
 144         info = *type_get_simple(ARGTYPE_LONG);
 145         info.lens = &guess_lens;
 146         ret = &info;
 147         return ret;
 148 }
 149
 150 /* The default prototype is: long X(long, long, long, long).  */
 151 static struct prototype *
 152 build_default_prototype(void)
 153 {
 154         static struct prototype *ret = NULL;
 155         if (ret != NULL)
 156                 return ret;
 157
 158         static struct prototype proto;
 159         prototype_init(&proto);
 160
 161         struct arg_type_info *unknown_type = get_unknown_type();
 162         assert(unknown_type != NULL);
 163         proto.return_info = unknown_type;
 164         proto.own_return_info = 0;
 165
 166         struct param unknown_param;
 167         param_init_type(&unknown_param, unknown_type, 0);
 168
 169         size_t i;
 170         for (i = 0; i < 4; ++i)
 171                 if (prototype_push_param(&proto, &unknown_param) < 0) {
 172                         report_global_error("build_default_prototype: %s",
 173                                             strerror(errno));
 174                         prototype_destroy(&proto);
 175                         return NULL;
 176                 }
 177
 178         ret = &proto;
 179         return ret;
 180 }
 181
 182 static bool
 183 snip_period(char *buf)
 184 {
 185         char *period = strrchr(buf, '.');
 186         if (period != NULL && strcmp(period, ".so") != 0) {
 187                 *period = 0;
 188                 return true;
 189         } else {
 190                 return false;
 191         }
 192 }
 193
 194 static struct prototype *
 195 library_get_prototype(struct library *lib, const char *name)
 196 {
 197         if (lib->protolib == NULL) {
 198                 size_t sz = strlen(lib->soname);
 199                 char buf[sz + 1];
 200                 memcpy(buf, lib->soname, sz + 1);
 201
 202                 do {
 203                         if (protolib_cache_maybe_load(&g_protocache, buf, 0,
 204                                                       true, &lib->protolib) < 0)
 205                                 return NULL;
 206                 } while (lib->protolib == NULL
 207                          && lib->type == LT_LIBTYPE_DSO
 208                          && snip_period(buf));
 209
 210                 if (lib->protolib == NULL)
 211                         lib->protolib = protolib_cache_default(&g_protocache,
 212                                                                buf, 0);
 213         }
 214         if (lib->protolib == NULL)
 215                 return NULL;
 216
 217         return protolib_lookup_prototype(lib->protolib, name,
 218                                          lib->type != LT_LIBTYPE_SYSCALL);
 219 }
 220
 221 struct find_proto_data {
 222         const char *name;
 223         struct prototype *ret;
 224 };
 225
 226 static enum callback_status
 227 find_proto_cb(struct process *proc, struct library *lib, void *d)
 228 {
 229         struct find_proto_data *data = d;
 230         data->ret = library_get_prototype(lib, data->name);
 231         return CBS_STOP_IF(data->ret != NULL);
 232 }
 233
 234 static struct prototype *
 235 lookup_symbol_prototype(struct process *proc, struct library_symbol *libsym)
 236 {
 237         if (libsym->proto != NULL)
 238                 return libsym->proto;
 239
 240         struct library *lib = libsym->lib;
 241         if (lib != NULL) {
 242                 struct find_proto_data data = { libsym->name };
 243                 data.ret = library_get_prototype(lib, libsym->name);
 244                 if (data.ret == NULL
 245                     && libsym->plt_type == LS_TOPLT_EXEC)
 246                         proc_each_library(proc, NULL, find_proto_cb, &data);
 247                 if (data.ret != NULL)
 248                         return data.ret;
 249         }
 250
 251         return build_default_prototype();
 252 }
 253
 254 void
 255 output_line(struct process *proc, const char *fmt, ...)
 256 {
 257         if (options.summary)
 258                 return;
 259
 260         if (current_proc != NULL) {
 261                 if (current_proc->callstack[current_depth].return_addr)
 262                         fprintf(options.output, " <unfinished ...>\n");
 263                 else
 264                         fprintf(options.output, " <no return ...>\n");
 265         }
 266         current_proc = NULL;
 267         if (fmt == NULL)
 268                 return;
 269
 270         begin_of_line(proc, 0, 0);
 271
 272         va_list args;
 273         va_start(args, fmt);
 274         vfprintf(options.output, fmt, args);
 275         fprintf(options.output, "\n");
 276         va_end(args);
 277
 278         current_column = 0;
 279 }
 280
 281 static void
 282 tabto(int col) {
 283         if (current_column < col) {
 284                 fprintf(options.output, "%*s", col - current_column, "");
 285         }
 286 }
 287
 288 static int
 289 output_error(FILE *stream)
 290 {
 291         return fprintf(stream, "?");
 292 }
 293
 294 static int
 295 fetch_simple_param(enum tof type, struct process *proc,
 296                    struct fetch_context *context,
 297                    struct value_dict *arguments,
 298                    struct arg_type_info *info, int own,
 299                    struct value *valuep)
 300 {
 301         /* Arrays decay into pointers per C standard.  We check for
 302          * this here, because here we also capture arrays that come
 303          * from parameter packs.  */
 304         if (info->type == ARGTYPE_ARRAY) {
 305                 struct arg_type_info *tmp = malloc(sizeof(*tmp));
 306                 if (tmp != NULL) {
 307                         type_init_pointer(tmp, info, own);
 308                         tmp->lens = info->lens;
 309                         info = tmp;
 310                         own = 1;
 311                 }
 312         }
 313
 314         struct value value;
 315         value_init(&value, proc, NULL, info, own);
 316         if (fetch_arg_next(context, type, proc, info, &value) < 0)
 317                 return -1;
 318
 319         if (val_dict_push_next(arguments, &value) < 0) {
 320                 value_destroy(&value);
 321                 return -1;
 322         }
 323
 324         if (valuep != NULL)
 325                 *valuep = value;
 326
 327         return 0;
 328 }
 329
 330 static void
 331 fetch_param_stop(struct value_dict *arguments, ssize_t *params_leftp)
 332 {
 333         if (*params_leftp == -1)
 334                 *params_leftp = val_dict_count(arguments);
 335 }
 336
 337 static int
 338 fetch_param_pack(enum tof type, struct process *proc,
 339                  struct fetch_context *context,
 340                  struct value_dict *arguments, struct param *param,
 341                  ssize_t *params_leftp)
 342 {
 343         struct param_enum *e = param_pack_init(param, arguments);
 344         if (e == NULL)
 345                 return -1;
 346
 347         int ret = 0;
 348         while (1) {
 349                 int insert_stop = 0;
 350                 struct arg_type_info *info = malloc(sizeof(*info));
 351                 if (info == NULL
 352                     || param_pack_next(param, e, info, &insert_stop) < 0) {
 353                 fail:
 354                         free(info);
 355                         ret = -1;
 356                         break;
 357                 }
 358
 359                 if (insert_stop)
 360                         fetch_param_stop(arguments, params_leftp);
 361
 362                 if (info->type == ARGTYPE_VOID) {
 363                         type_destroy(info);
 364                         free(info);
 365                         break;
 366                 }
 367
 368                 struct value val;
 369                 if (fetch_simple_param(type, proc, context, arguments,
 370                                        info, 1, &val) < 0)
 371                         goto fail;
 372
 373                 int stop = 0;
 374                 switch (param_pack_stop(param, e, &val)) {
 375                 case PPCB_ERR:
 376                         goto fail;
 377                 case PPCB_STOP:
 378                         stop = 1;
 379                 case PPCB_CONT:
 380                         break;
 381                 }
 382
 383                 if (stop)
 384                         break;
 385         }
 386
 387         param_pack_done(param, e);
 388         return ret;
 389 }
 390
 391 static int
 392 fetch_one_param(enum tof type, struct process *proc,
 393                 struct fetch_context *context,
 394                 struct value_dict *arguments, struct param *param,
 395                 ssize_t *params_leftp)
 396 {
 397         switch (param->flavor) {
 398                 int rc;
 399         case PARAM_FLAVOR_TYPE:
 400                 return fetch_simple_param(type, proc, context, arguments,
 401                                           param->u.type.type, 0, NULL);
 402
 403         case PARAM_FLAVOR_PACK:
 404                 if (fetch_param_pack_start(context,
 405                                            param->u.pack.ppflavor) < 0)
 406                         return -1;
 407                 rc = fetch_param_pack(type, proc, context, arguments,
 408                                       param, params_leftp);
 409                 fetch_param_pack_end(context);
 410                 return rc;
 411
 412         case PARAM_FLAVOR_STOP:
 413                 fetch_param_stop(arguments, params_leftp);
 414                 return 0;
 415         }
 416
 417         assert(!"Invalid param flavor!");
 418         abort();
 419 }
 420
 421 struct fetch_one_param_data
 422 {
 423         struct process *proc;
 424         struct fetch_context *context;
 425         struct value_dict *arguments;
 426         ssize_t *params_leftp;
 427         enum tof tof;
 428 };
 429
 430 static enum callback_status
 431 fetch_one_param_cb(struct prototype *proto, struct param *param, void *data)
 432 {
 433         struct fetch_one_param_data *cb_data = data;
 434         return CBS_STOP_IF(fetch_one_param(cb_data->tof, cb_data->proc,
 435                                            cb_data->context,
 436                                            cb_data->arguments, param,
 437                                            cb_data->params_leftp) < 0);
 438 }
 439
 440 static int
 441 fetch_params(enum tof type, struct process *proc,
 442              struct fetch_context *context,
 443              struct value_dict *arguments, struct prototype *func,
 444              ssize_t *params_leftp)
 445 {
 446         struct fetch_one_param_data cb_data
 447                 = { proc, context, arguments, params_leftp, type };
 448         if (prototype_each_param(func, NULL,
 449                                  &fetch_one_param_cb, &cb_data) != NULL)
 450                 return -1;
 451
 452         /* Implicit stop at the end of parameter list.  */
 453         fetch_param_stop(arguments, params_leftp);
 454
 455         return 0;
 456 }
 457
 458 struct format_argument_data
 459 {
 460         struct value *value;
 461         struct value_dict *arguments;
 462 };
 463
 464 static int
 465 format_argument_cb(FILE *stream, void *ptr)
 466 {
 467         struct format_argument_data *data = ptr;
 468         int o = format_argument(stream, data->value, data->arguments);
 469         if (o < 0)
 470                 o = output_error(stream);
 471         return o;
 472 }
 473
 474 static int
 475 output_params(struct value_dict *arguments, size_t start, size_t end,
 476               int *need_delimp)
 477 {
 478         size_t i;
 479         for (i = start; i < end; ++i) {
 480                 struct value *value = val_dict_get_num(arguments, i);
 481                 if (value == NULL)
 482                         return -1;
 483
 484                 struct format_argument_data data = { value, arguments };
 485                 int o = delim_output(options.output, need_delimp,
 486                                      format_argument_cb, &data);
 487                 if (o < 0)
 488                         return -1;
 489                 current_column += o;
 490         }
 491         return 0;
 492 }
 493
 494 void
 495 output_left(enum tof type, struct process *proc,
 496             struct library_symbol *libsym)
 497 {
 498         assert(! options.summary);
 499
 500         if (current_proc) {
 501                 fprintf(options.output, " <unfinished ...>\n");
 502                 current_column = 0;
 503         }
 504         current_proc = proc;
 505         current_depth = proc->callstack_depth;
 506         begin_of_line(proc, type == LT_TOF_FUNCTION, 1);
 507         if (!options.hide_caller && libsym->lib != NULL
 508             && libsym->plt_type != LS_TOPLT_NONE)
 509                 /* We don't terribly mind failing this.  */
 510                 account_output(&current_column,
 511                                fprintf(options.output, "%s->",
 512                                        libsym->lib->soname));
 513
 514         const char *name = libsym->name;
 515 #ifdef USE_DEMANGLE
 516         if (options.demangle)
 517                 name = my_demangle(libsym->name);
 518 #endif
 519         if (account_output(&current_column,
 520                            fprintf(options.output, "%s", name)) < 0)
 521                 return;
 522
 523         if (libsym->lib != NULL
 524             && libsym->lib->type != LT_LIBTYPE_MAIN
 525             && libsym->plt_type == LS_TOPLT_NONE
 526             && account_output(&current_column,
 527                               fprintf(options.output, "@%s",
 528                                       libsym->lib->soname)) < 0)
 529                 /* We do mind failing this though.  */
 530                 return;
 531
 532         account_output(&current_column, fprintf(options.output, "("));
 533
 534         struct prototype *func = lookup_symbol_prototype(proc, libsym);
 535         if (func == NULL) {
 536         fail:
 537                 account_output(&current_column, fprintf(options.output, "???"));
 538                 return;
 539         }
 540
 541         struct fetch_context *context = fetch_arg_init(type, proc,
 542                                                        func->return_info);
 543         if (context == NULL)
 544                 goto fail;
 545
 546         struct value_dict *arguments = malloc(sizeof(*arguments));
 547         if (arguments == NULL) {
 548                 fetch_arg_done(context);
 549                 goto fail;
 550         }
 551         val_dict_init(arguments);
 552
 553         ssize_t params_left = -1;
 554         int need_delim = 0;
 555         if (fetch_params(type, proc, context, arguments, func, &params_left) < 0
 556             || output_params(arguments, 0, params_left, &need_delim) < 0) {
 557                 val_dict_destroy(arguments);
 558                 fetch_arg_done(context);
 559                 arguments = NULL;
 560                 context = NULL;
 561         }
 562
 563         struct callstack_element *stel
 564                 = &proc->callstack[proc->callstack_depth - 1];
 565         stel->fetch_context = context;
 566         stel->arguments = arguments;
 567         stel->out.params_left = params_left;
 568         stel->out.need_delim = need_delim;
 569 }
 570
 571 #if defined(HAVE_LIBDW)
 572 /* Prints information about one frame of a thread.  Called by
 573    dwfl_getthread_frames in output_right.  Returns 1 when done (max
 574    number of frames reached).  Returns -1 on error.  Returns 0 on
 575    success (if there are more frames in the thread, call us again).  */
 576 static int
 577 frame_callback (Dwfl_Frame *state, void *arg)
 578 {
 579         Dwarf_Addr pc;
 580         bool isactivation;
 581
 582         int *frames = (int *) arg;
 583
 584         if (!dwfl_frame_pc(state, &pc, &isactivation))
 585                 return -1;
 586
 587         if (!isactivation)
 588                 pc--;
 589
 590         Dwfl *dwfl = dwfl_thread_dwfl(dwfl_frame_thread(state));
 591         Dwfl_Module *mod = dwfl_addrmodule(dwfl, pc);
 592         const char *modname = NULL;
 593         const char *symname = NULL;
 594         GElf_Off off = 0;
 595         if (mod != NULL) {
 596                 GElf_Sym sym;
 597                 modname = dwfl_module_info(mod, NULL, NULL, NULL, NULL,
 598                                            NULL, NULL, NULL);
 599                 symname = dwfl_module_addrinfo(mod, pc, &off, &sym,
 600                                                NULL, NULL, NULL);
 601         }
 602
 603         /* This mimics the output produced by libunwind below.  */
 604         fprintf(options.output, " > %s(%s+0x%" PRIx64 ") [%" PRIx64 "]\n",
 605                 modname, symname, off, pc);
 606
 607         /* See if we can extract the source line too and print it on
 608            the next line if we can find it.  */
 609         if (mod != NULL) {
 610                 Dwfl_Line *l = dwfl_module_getsrc(mod, pc);
 611                 if (l != NULL) {
 612                         int line, col;
 613                         line = col = -1;
 614                         const char *src = dwfl_lineinfo(l, NULL, &line, &col,
 615                                                         NULL, NULL);
 616                         if (src != NULL) {
 617                                 fprintf(options.output, "\t%s", src);
 618                                 if (line > 0) {
 619                                         fprintf(options.output, ":%d", line);
 620                                         if (col > 0)
 621                                                 fprintf(options.output,
 622                                                         ":%d", col);
 623                                 }
 624                                 fprintf(options.output, "\n");
 625                         }
 626
 627                 }
 628         }
 629
 630         /* Max number of frames to print reached? */
 631         if ((*frames)-- == 0)
 632                 return 1;
 633
 634         return 0;
 635 }
 636 #endif /* defined(HAVE_LIBDW) */
 637
 638 void
 639 output_right(enum tof type, struct process *proc, struct library_symbol *libsym,
 640              struct timedelta *spent)
 641 {
 642         assert(! options.summary);
 643
 644         struct prototype *func = lookup_symbol_prototype(proc, libsym);
 645         if (func == NULL)
 646                 return;
 647
 648         if (current_proc != NULL
 649                     && (current_proc != proc
 650                         || current_depth != proc->callstack_depth)) {
 651                 fprintf(options.output, " <unfinished ...>\n");
 652                 current_proc = NULL;
 653         }
 654         if (current_proc != proc) {
 655                 begin_of_line(proc, type == LT_TOF_FUNCTIONR, 1);
 656 #ifdef USE_DEMANGLE
 657                 current_column +=
 658                     fprintf(options.output, "<... %s resumed> ",
 659                             options.demangle ? my_demangle(libsym->name)
 660                             : libsym->name);
 661 #else
 662                 current_column +=
 663                     fprintf(options.output, "<... %s resumed> ", libsym->name);
 664 #endif
 665         }
 666
 667         struct callstack_element *stel
 668                 = &proc->callstack[proc->callstack_depth - 1];
 669
 670         struct fetch_context *context = stel->fetch_context;
 671
 672         /* Fetch & enter into dictionary the retval first, so that
 673          * other values can use it in expressions.  */
 674         struct value retval;
 675         bool own_retval = false;
 676         if (context != NULL) {
 677                 value_init(&retval, proc, NULL, func->return_info, 0);
 678                 own_retval = true;
 679                 if (fetch_retval(context, type, proc, func->return_info,
 680                                  &retval) < 0)
 681                         value_set_type(&retval, NULL, 0);
 682                 else if (stel->arguments != NULL
 683                          && val_dict_push_named(stel->arguments, &retval,
 684                                                 "retval", 0) == 0)
 685                         own_retval = false;
 686         }
 687
 688         if (stel->arguments != NULL)
 689                 output_params(stel->arguments, stel->out.params_left,
 690                               val_dict_count(stel->arguments),
 691                               &stel->out.need_delim);
 692
 693         current_column += fprintf(options.output, ") ");
 694         tabto(options.align - 1);
 695         fprintf(options.output, "= ");
 696
 697         if (context != NULL && retval.type != NULL) {
 698                 struct format_argument_data data = { &retval, stel->arguments };
 699                 format_argument_cb(options.output, &data);
 700         }
 701
 702         if (own_retval)
 703                 value_destroy(&retval);
 704
 705         if (opt_T) {
 706                 assert(spent != NULL);
 707                 fprintf(options.output, " <%lu.%06d>",
 708                         (unsigned long) spent->tm.tv_sec,
 709                         (int) spent->tm.tv_usec);
 710         }
 711
 712         fprintf(options.output, "\n");
 713
 714 #if defined(HAVE_LIBUNWIND)
 715         if (options.bt_depth > 0
 716             && proc->unwind_priv != NULL
 717             && proc->unwind_as != NULL) {
 718                 unw_cursor_t cursor;
 719                 arch_addr_t ip, function_offset;
 720                 struct library *lib = NULL;
 721                 int unwind_depth = options.bt_depth;
 722                 char fn_name[100];
 723                 const char *lib_name;
 724                 size_t distance;
 725
 726                 /* Verify that we can safely cast arch_addr_t* to
 727                  * unw_word_t*.  */
 728                 (void)sizeof(char[1 - 2*(sizeof(unw_word_t)
 729                                         != sizeof(arch_addr_t))]);
 730                 unw_init_remote(&cursor, proc->unwind_as, proc->unwind_priv);
 731                 while (unwind_depth) {
 732
 733                         int rc = unw_get_reg(&cursor, UNW_REG_IP,
 734                                              (unw_word_t *) &ip);
 735                         if (rc < 0) {
 736                                 fprintf(options.output, " > Error: %s\n",
 737                                         unw_strerror(rc));
 738                                 goto cont;
 739                         }
 740
 741                         /* We are looking for the library with the base address
 742                          * closest to the current ip.  */
 743                         lib_name = "unmapped_area";
 744                         distance = (size_t) -1;
 745                         lib = proc->libraries;
 746                         while (lib != NULL) {
 747                                 /* N.B.: Assumes sizeof(size_t) ==
 748                                  * sizeof(arch_addr_t).
 749                                  * Keyword: double cast.  */
 750                                 if ((ip >= lib->base) &&
 751                                             ((size_t)(ip - lib->base)
 752                                             < distance)) {
 753                                         distance = ip - lib->base;
 754                                         lib_name = lib->pathname;
 755                                 }
 756                                 lib = lib->next;
 757                         }
 758
 759                         rc = unw_get_proc_name(&cursor, fn_name,
 760                                                sizeof(fn_name),
 761                                                (unw_word_t *) &function_offset);
 762                         if (rc == 0 || rc == -UNW_ENOMEM)
 763                                 fprintf(options.output, " > %s(%s+%p) [%p]\n",
 764                                         lib_name, fn_name, function_offset, ip);
 765                         else
 766                                 fprintf(options.output, " > %s(??\?) [%p]\n",
 767                                         lib_name, ip);
 768
 769                 cont:
 770                         if (unw_step(&cursor) <= 0)
 771                                 break;
 772                         unwind_depth--;
 773                 }
 774                 fprintf(options.output, "\n");
 775         }
 776 #endif /* defined(HAVE_LIBUNWIND) */
 777
 778 #if defined(HAVE_LIBDW)
 779         if (options.bt_depth > 0 && proc->leader->dwfl != NULL) {
 780                 int frames = options.bt_depth;
 781                 if (dwfl_getthread_frames(proc->leader->dwfl, proc->pid,
 782                                           frame_callback, &frames) < 0) {
 783                         // Only print an error if we couldn't show anything.
 784                         // Otherwise just show there might be more...
 785                         if (frames == options.bt_depth)
 786                                 fprintf(stderr,
 787                                         "dwfl_getthread_frames tid %d: %s\n",
 788                                         proc->pid, dwfl_errmsg(-1));
 789                         else
 790                                 fprintf(options.output, " > [...]\n");
 791                 }
 792                 fprintf(options.output, "\n");
 793           }
 794 #endif /* defined(HAVE_LIBDW) */
 795
 796         current_proc = NULL;
 797         current_column = 0;
 798 }
 799
 800 int
 801 delim_output(FILE *stream, int *need_delimp,
 802              int (*writer)(FILE *stream, void *data),
 803              void *data)
 804 {
 805         int o;
 806
 807         /* If we don't need a delimiter, then we don't need to go
 808          * through a temporary stream.  It's all the same whether
 809          * WRITER emits anything or not.  */
 810         if (!*need_delimp) {
 811                 o = writer(stream, data);
 812
 813         } else {
 814                 struct memstream ms;
 815                 if (memstream_init(&ms) < 0)
 816                         return -1;
 817                 o = writer(ms.stream, data);
 818                 if (memstream_close(&ms) < 0)
 819                         o = -1;
 820                 if (o > 0 && ((*need_delimp
 821                                && account_output(&o, fprintf(stream, ", ")) < 0)
 822                               || fwrite(ms.buf, 1, ms.size, stream) != ms.size))
 823                         o = -1;
 824
 825                 memstream_destroy(&ms);
 826         }
 827
 828         if (o < 0)
 829                 return -1;
 830
 831         *need_delimp = *need_delimp || o > 0;
 832         return o;
 833 }
 834
 835 int
 836 account_output(int *countp, int c)
 837 {
 838         if (c > 0)
 839                 *countp += c;
 840         return c;
 841 }
 842
 843 static void
 844 do_report(const char *filename, unsigned line_no, const char *severity,
 845           const char *fmt, va_list args)
 846 {
 847         char buf[128];
 848         vsnprintf(buf, sizeof(buf), fmt, args);
 849         buf[sizeof(buf) - 1] = 0;
 850         if (filename != NULL)
 851                 output_line(0, "%s:%d: %s: %s",
 852                             filename, line_no, severity, buf);
 853         else
 854                 output_line(0, "%s: %s", severity, buf);
 855 }
 856
 857 void
 858 report_error(const char *filename, unsigned line_no, const char *fmt, ...)
 859 {
 860         va_list args;
 861         va_start(args, fmt);
 862         do_report(filename, line_no, "error", fmt, args);
 863         va_end(args);
 864 }
 865
 866 void
 867 report_warning(const char *filename, unsigned line_no, const char *fmt, ...)
 868 {
 869         va_list args;
 870         va_start(args, fmt);
 871         do_report(filename, line_no, "warning", fmt, args);
 872         va_end(args);
 873 }
 874
 875 void
 876 report_global_error(const char *fmt, ...)
 877 {
 878         va_list args;
 879         va_start(args, fmt);
 880         do_report(NULL, 0, "error", fmt, args);
 881         va_end(args);
 882 }