output.c revision 98a7dce70986f2394d22ee5dd8ed355ceb2104b4 
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: */
52extern struct timeval current_time_spent;
53
54struct dict *dict_opt_c = NULL;
55
56static struct process *current_proc = 0;
57static size_t current_depth = 0;
58static int current_column = 0;
59
60static void
61output_indent(struct process *proc)
62{
63	int d = options.indent * (proc->callstack_depth - 1);
64	current_column += fprintf(options.output, "%*s", d, "");
65}
66
67static void
68begin_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
139static struct arg_type_info *
140get_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).  */
154static struct prototype *
155build_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
185static bool
186snip_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
197static struct prototype *
198library_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);
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
224struct find_proto_data {
225	const char *name;
226	struct prototype *ret;
227};
228
229static enum callback_status
230find_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
237static struct prototype *
238lookup_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
257void
258output_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
284static void
285tabto(int col) {
286	if (current_column < col) {
287		fprintf(options.output, "%*s", col - current_column, "");
288	}
289}
290
291static int
292output_error(FILE *stream)
293{
294	return fprintf(stream, "?");
295}
296
297static int
298fetch_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
333static void
334fetch_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
340static int
341fetch_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
394static int
395fetch_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
424struct 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
433static enum callback_status
434fetch_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
443static int
444fetch_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
461struct format_argument_data
462{
463	struct value *value;
464	struct value_dict *arguments;
465};
466
467static int
468format_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
477static int
478output_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
497void
498output_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
575static void
576free_stringp_cb(const char **stringp, void *data)
577{
578	free((char *)*stringp);
579}
580
581void
582output_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
588again:
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
753int
754delim_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
788int
789account_output(int *countp, int c)
790{
791	if (c > 0)
792		*countp += c;
793	return c;
794}
795
796static void
797do_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
810void
811report_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
819void
820report_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
828void
829report_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}
836