/*
* This file is part of ltrace.
* Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc.
* Copyright (C) 1998,2004,2007,2008,2009 Juan Cespedes
* Copyright (C) 2006 Ian Wienand
* Copyright (C) 2006 Steve Fink
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
#define _XOPEN_SOURCE /* For wcwidth from wchar.h. */
#include <ctype.h>
#include <stdlib.h>
#include <assert.h>
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>
#include "bits.h"
#include "expr.h"
#include "lens_default.h"
#include "options.h"
#include "output.h"
#include "type.h"
#include "value.h"
#include "zero.h"
#define READER(NAME, TYPE) \
static int \
NAME(struct value *value, TYPE *ret, struct value_dict *arguments) \
{ \
union { \
TYPE val; \
unsigned char buf[0]; \
} u; \
if (value_extract_buf(value, u.buf, arguments) < 0) \
return -1; \
*ret = u.val; \
return 0; \
}
READER(read_float, float)
READER(read_double, double)
#undef READER
#define HANDLE_WIDTH(BITS) \
do { \
long l; \
if (value_extract_word(value, &l, arguments) < 0) \
return -1; \
int##BITS##_t i = l; \
uint64_t v = (uint64_t)(uint##BITS##_t)i; \
switch (format) { \
case INT_FMT_unknown: \
if (l < -10000 || l > 10000) \
case INT_FMT_x: \
return fprintf(stream, "%#"PRIx64, v); \
case INT_FMT_i: \
case INT_FMT_default: \
return fprintf(stream, "%"PRIi##BITS, i); \
case INT_FMT_u: \
return fprintf(stream, "%"PRIu64, v); \
case INT_FMT_o: \
return fprintf(stream, "0%"PRIo64, v); \
} \
} while (0)
enum int_fmt_t
{
INT_FMT_i,
INT_FMT_u,
INT_FMT_o,
INT_FMT_x,
INT_FMT_unknown,
INT_FMT_default,
};
static int
format_integer(FILE *stream, struct value *value, enum int_fmt_t format,
struct value_dict *arguments)
{
switch (type_sizeof(value->inferior, value->type)) {
case 1: HANDLE_WIDTH(8);
case 2: HANDLE_WIDTH(16);
case 4: HANDLE_WIDTH(32);
case 8: HANDLE_WIDTH(64);
default:
assert(!"unsupported integer width");
abort();
case -1:
return -1;
}
}
#undef HANDLE_WIDTH
static int
acc_fprintf(int *countp, FILE *stream, const char *format, ...)
{
va_list pa;
va_start(pa, format);
int i = account_output(countp, vfprintf(stream, format, pa));
va_end(pa);
return i;
}
static int
print_char(FILE *stream, int c)
{
const char *fmt;
switch (c) {
case -1:
fmt = "EOF";
break;
case 0:
fmt = "\\0";
break;
case '\a':
fmt = "\\a";
break;
case '\b':
fmt = "\\b";
break;
case '\t':
fmt = "\\t";
break;
case '\n':
fmt = "\\n";
break;
case '\v':
fmt = "\\v";
break;
case '\f':
fmt = "\\f";
break;
case '\r':
fmt = "\\r";
break;
case '\\':
fmt = "\\\\";
break;
default:
if (isprint(c) || c == ' ')
fmt = "%c";
else
fmt = "\\%03o";
}
return fprintf(stream, fmt, c);
}
static int
format_char(FILE *stream, struct value *value, struct value_dict *arguments)
{
long lc;
if (value_extract_word(value, &lc, arguments) < 0)
return -1;
return print_char(stream, (int) lc);
}
static int
format_naked(FILE *stream, struct value *value,
struct value_dict *arguments,
int (*what)(FILE *, struct value *, struct value_dict *))
{
int written = 0;
if (acc_fprintf(&written, stream, "'") < 0
|| account_output(&written,
what(stream, value, arguments)) < 0
|| acc_fprintf(&written, stream, "'") < 0)
return -1;
return written;
}
static int
format_double(FILE *stream, double value, enum int_fmt_t format)
{
if (format == INT_FMT_x)
return fprintf(stream, "%a", value);
else
return fprintf(stream, "%f", value);
}
static int
format_floating(FILE *stream, struct value *value, struct value_dict *arguments,
enum int_fmt_t format)
{
switch (value->type->type) {
float f;
double d;
case ARGTYPE_FLOAT:
if (read_float(value, &f, arguments) < 0)
return -1;
return format_double(stream, f, format);
case ARGTYPE_DOUBLE:
if (read_double(value, &d, arguments) < 0)
return -1;
return format_double(stream, d, format);
default:
abort();
}
}
struct format_argument_data
{
struct value *value;
struct value_dict *arguments;
};
static int
format_argument_cb(FILE *stream, void *ptr)
{
struct format_argument_data *data = ptr;
return format_argument(stream, data->value, data->arguments);
}
static int
format_struct(FILE *stream, struct value *value, struct value_dict *arguments)
{
int written = 0;
if (acc_fprintf(&written, stream, "{ ") < 0)
return -1;
int need_delim = 0;
size_t i;
for (i = 0; i < type_struct_size(value->type); ++i) {
struct value element;
if (value_init_element(&element, value, i) < 0)
return -1;
struct format_argument_data data = { &element, arguments };
int o = delim_output(stream, &need_delim,
format_argument_cb, &data);
value_destroy(&element);
if (o < 0)
return -1;
written += o;
}
if (acc_fprintf(&written, stream, " }") < 0)
return -1;
return written;
}
static const char null_message[] = "nil";
int
format_pointer(FILE *stream, struct value *value, struct value_dict *arguments)
{
if (value_is_zero(value, arguments))
return fprintf(stream, null_message);
/* The following is for detecting recursion. We keep track of
* the values that were already displayed. Each time a
* pointer should be dereferenced, we compare its value to the
* value of each of the pointers dereferenced so far. If one
* of them matches, instead of recursing, we just printf which
* superstructure this pointer recurses to. */
static struct vect pointers = {};
if (pointers.elt_size == 0)
VECT_INIT(&pointers, struct value *);
/* Trim number of expanded structures of the same type. Even
* for non-recursive structure, we don't want to expand all of
* it if it's huge. */
size_t i;
size_t len = vect_size(&pointers);
assert(value->type->type == ARGTYPE_POINTER);
struct arg_type_info *pointee = value->type->u.ptr_info.info;
if (pointee->type == ARGTYPE_STRUCT) {
size_t depth = 0;
for (i = 0; i < len; ++i) {
struct value *old
= *VECT_ELEMENT(&pointers, struct value *, i);
assert(old->type->type == ARGTYPE_POINTER);
struct arg_type_info *old_pointee
= old->type->u.ptr_info.info;
if (old_pointee == pointee)
depth++;
}
if (depth >= options.arraylen)
return fprintf(stream, "...");
}
for (i = len; i-- > 0 ;) {
struct value **old = VECT_ELEMENT(&pointers, struct value *, i);
int rc = value_equal(value, *old, arguments);
if (rc < 0)
return -1;
if (rc > 0) {
size_t reclevel = len - i - 1;
char buf[reclevel + 1];
memset(buf, '^', sizeof buf);
buf[reclevel] = 0;
return fprintf(stream, "recurse%s", buf);
}
}
/* OK, not a recursion. Remember this value for tracking. */
if (VECT_PUSHBACK(&pointers, &value) < 0)
return -1;
struct value element;
int o;
if (value_init_deref(&element, value) < 0) {
o = -1;
goto done;
}
o = format_argument(stream, &element, arguments);
value_destroy(&element);
done:
VECT_POPBACK(&pointers, struct value *, NULL, NULL);
return o;
}
/*
* LENGTH is an expression whose evaluation will yield the actual
* length of the array.
*
* MAXLEN is the actual maximum length that we care about
*
* BEFORE if LENGTH>MAXLEN, we display ellipsis. We display it before
* the closing parenthesis if BEFORE, otherwise after it.
*
* OPEN, CLOSE, DELIM are opening and closing parenthesis and element
* delimiter.
*/
static int
format_array(FILE *stream, struct value *value, struct value_dict *arguments,
struct expr_node *length, size_t maxlen, int before,
const char *open, const char *close, const char *delim)
{
/* We need "long" to be long enough to cover the whole address
* space. */
(void)sizeof(char[1 - 2*(sizeof(long) < sizeof(void *))]);
long l;
if (expr_eval_word(length, value, arguments, &l) < 0)
return -1;
size_t len = (size_t)l;
int written = 0;
if (acc_fprintf(&written, stream, "%s", open) < 0)
return -1;
size_t i;
for (i = 0; i < len && i <= maxlen; ++i) {
if (i == maxlen) {
if (before && acc_fprintf(&written, stream, "...") < 0)
return -1;
break;
}
if (i > 0 && acc_fprintf(&written, stream, "%s", delim) < 0)
return -1;
struct value element;
if (value_init_element(&element, value, i) < 0)
return -1;
int o = format_argument(stream, &element, arguments);
value_destroy(&element);
if (o < 0)
return -1;
written += o;
}
if (acc_fprintf(&written, stream, "%s", close) < 0)
return -1;
if (i == maxlen && !before && acc_fprintf(&written, stream, "...") < 0)
return -1;
return written;
}
static int
toplevel_format_lens(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments,
enum int_fmt_t int_fmt)
{
switch (value->type->type) {
case ARGTYPE_VOID:
return fprintf(stream, "<void>");
case ARGTYPE_SHORT:
case ARGTYPE_INT:
case ARGTYPE_LONG:
return format_integer(stream, value, int_fmt, arguments);
case ARGTYPE_USHORT:
case ARGTYPE_UINT:
case ARGTYPE_ULONG:
if (int_fmt == INT_FMT_i || int_fmt == INT_FMT_default)
int_fmt = INT_FMT_u;
return format_integer(stream, value, int_fmt, arguments);
case ARGTYPE_CHAR:
if (int_fmt == INT_FMT_default)
return format_naked(stream, value, arguments,
&format_char);
return format_integer(stream, value, int_fmt, arguments);
case ARGTYPE_FLOAT:
case ARGTYPE_DOUBLE:
return format_floating(stream, value, arguments, int_fmt);
case ARGTYPE_STRUCT:
return format_struct(stream, value, arguments);
case ARGTYPE_POINTER:
if (value_is_zero(value, arguments))
return fprintf(stream, null_message);
if (value->type->u.array_info.elt_type->type != ARGTYPE_VOID)
return format_pointer(stream, value, arguments);
return format_integer(stream, value, INT_FMT_x, arguments);
case ARGTYPE_ARRAY:
return format_array(stream, value, arguments,
value->type->u.array_info.length,
options.arraylen, 1, "[ ", " ]", ", ");
}
abort();
}
static int
default_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return toplevel_format_lens(lens, stream, value, arguments,
INT_FMT_default);
}
struct lens default_lens = {
.format_cb = default_lens_format_cb,
};
static int
blind_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return 0;
}
struct lens blind_lens = {
.format_cb = blind_lens_format_cb,
};
static int
octal_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_o);
}
struct lens octal_lens = {
.format_cb = octal_lens_format_cb,
};
static int
hex_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_x);
}
struct lens hex_lens = {
.format_cb = hex_lens_format_cb,
};
static int
dec_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_u);
}
struct lens dec_lens = {
.format_cb = dec_lens_format_cb,
};
static int
guess_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
return toplevel_format_lens(lens, stream, value, arguments,
INT_FMT_unknown);
}
struct lens guess_lens = {
.format_cb = guess_lens_format_cb,
};
static int
bool_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
switch (value->type->type) {
case ARGTYPE_VOID:
case ARGTYPE_FLOAT:
case ARGTYPE_DOUBLE:
case ARGTYPE_STRUCT:
case ARGTYPE_POINTER:
case ARGTYPE_ARRAY:
return toplevel_format_lens(lens, stream, value,
arguments, INT_FMT_default);
int zero;
case ARGTYPE_SHORT:
case ARGTYPE_INT:
case ARGTYPE_LONG:
case ARGTYPE_USHORT:
case ARGTYPE_UINT:
case ARGTYPE_ULONG:
case ARGTYPE_CHAR:
if ((zero = value_is_zero(value, arguments)) < 0)
return -1;
if (zero)
return fprintf(stream, "false");
else
return fprintf(stream, "true");
}
abort();
}
struct lens bool_lens = {
.format_cb = bool_lens_format_cb,
};
static int
redispatch_as_array(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments,
int (*cb)(struct lens *, FILE *,
struct value *, struct value_dict *))
{
struct arg_type_info info[2];
type_init_array(&info[1], value->type->u.ptr_info.info, 0,
expr_node_zero(), 0);
type_init_pointer(&info[0], &info[1], 0);
info->lens = lens;
info->own_lens = 0;
struct value tmp;
if (value_clone(&tmp, value) < 0)
return -1;
value_set_type(&tmp, info, 0);
int ret = cb(lens, stream, &tmp, arguments);
type_destroy(&info[0]);
type_destroy(&info[1]);
value_destroy(&tmp);
return ret;
}
static int
format_wchar(FILE *stream, struct value *value, struct value_dict *arguments)
{
long l;
if (value_extract_word(value, &l, arguments) < 0)
return -1;
wchar_t wc = (wchar_t) l;
char buf[MB_CUR_MAX + 1];
int c = wctomb(buf, wc);
if (c < 0)
return -1;
if (c == 1)
return print_char(stream, buf[0]);
buf[c] = 0;
if (fprintf(stream, "%s", buf) < 0)
return -1;
c = wcwidth(wc);
return c >= 0 ? c : 0;
}
static int
string_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
switch (value->type->type) {
case ARGTYPE_POINTER:
/* This should really be written as either "string",
* or, if lens, then string(array(char, zero)*). But
* I suspect people are so used to the char * C idiom,
* that string(char *) might actually turn up. So
* let's just support it. */
switch ((int) value->type->u.ptr_info.info->type)
case ARGTYPE_CHAR:
case ARGTYPE_SHORT:
case ARGTYPE_USHORT:
case ARGTYPE_INT:
case ARGTYPE_UINT:
case ARGTYPE_LONG:
case ARGTYPE_ULONG:
return redispatch_as_array(lens, stream, value,
arguments,
&string_lens_format_cb);
/* Otherwise dispatch to whatever the default for the
* pointee is--most likely this will again be us. */
/* Fall through. */
case ARGTYPE_VOID:
case ARGTYPE_FLOAT:
case ARGTYPE_DOUBLE:
case ARGTYPE_STRUCT:
return toplevel_format_lens(lens, stream, value,
arguments, INT_FMT_default);
case ARGTYPE_SHORT:
case ARGTYPE_INT:
case ARGTYPE_LONG:
case ARGTYPE_USHORT:
case ARGTYPE_UINT:
case ARGTYPE_ULONG:
if (value->parent != NULL && value->type->lens == NULL)
return format_wchar(stream, value, arguments);
else
return format_naked(stream, value, arguments,
&format_wchar);
case ARGTYPE_CHAR:
return format_char(stream, value, arguments);
case ARGTYPE_ARRAY:
return format_array(stream, value, arguments,
value->type->u.array_info.length,
options.strlen, 0, "\"", "\"", "");
}
abort();
}
struct lens string_lens = {
.format_cb = string_lens_format_cb,
};
static int
out_bits(FILE *stream, size_t low, size_t high)
{
if (low == high)
return fprintf(stream, "%zd", low);
else
return fprintf(stream, "%zd-%zd", low, high);
}
static int
bitvect_lens_format_cb(struct lens *lens, FILE *stream,
struct value *value, struct value_dict *arguments)
{
unsigned char *data = value_get_data(value, arguments);
if (data == NULL)
return -1;
size_t sz = type_sizeof(value->inferior, value->type);
if (sz == (size_t)-1)
return -1;
size_t i;
unsigned char buf[sz];
switch ((int)value->type->type) {
union bitvect_integral_64
{
uint8_t u8;
uint16_t u16;
uint32_t u32;
uint64_t u64;
unsigned char buf[0];
} bv;
case ARGTYPE_POINTER:
return format_pointer(stream, value, arguments);
case ARGTYPE_STRUCT:
case ARGTYPE_ARRAY:
break;
default:
assert(sz <= sizeof(bv));
memmove(bv.buf, data, sz);
if (sz == 1)
bv.u64 = bv.u8;
else if (sz == 2)
bv.u64 = bv.u16;
else if (sz == 4)
bv.u64 = bv.u32;
for (i = 0; i < sz; ++i) {
buf[i] = bv.u64 & 0xff;
bv.u64 >>= 8;
}
data = buf;
}
size_t bits = 0;
for (i = 0; i < sz; ++i)
bits += bitcount(data[i]);
/* If there's more 1's than 0's, show inverse. */
unsigned neg = bits > sz * 4 ? 0xff : 0x00;
int o = 0;
if (acc_fprintf(&o, stream, "%s<", &"~"[neg == 0x00]) < 0)
return -1;
size_t bitno = 0;
ssize_t low = -1;
for (i = 0; i < sz; ++i) {
unsigned char m;
unsigned char d = data[i] ^ neg;
for (m = 0x01; m != 0; m <<= 1) {
int bit = !!(m & d);
if (low < 0) {
if (bit) {
if (low == -2
&& acc_fprintf(&o, stream, ",") < 0)
return -1;
low = bitno;
}
} else if (!bit) {
if (account_output(&o, out_bits(stream, low,
bitno-1)) < 0)
return -1;
low = -2;
}
bitno++;
}
}
if (low >= 0 && account_output(&o, out_bits(stream, low, bitno-1)) < 0)
return -1;
if (fputc('>', stream) < 0)
return -1;
o += 1;
return o;
}
struct lens bitvect_lens = {
.format_cb = bitvect_lens_format_cb,
};