output.c

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