1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc. 4 * Copyright (C) 1998,2004,2007,2008,2009 Juan Cespedes 5 * Copyright (C) 2006 Ian Wienand 6 * Copyright (C) 2006 Steve Fink 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of the 11 * License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 */ 23 24 #define _XOPEN_SOURCE /* For wcwidth from wchar.h. */ 25 26 #include <ctype.h> 27 #include <stdlib.h> 28 #include <assert.h> 29 #include <inttypes.h> 30 #include <stdarg.h> 31 #include <stdio.h> 32 #include <string.h> 33 #include <wchar.h> 34 35 #include "bits.h" 36 #include "expr.h" 37 #include "lens_default.h" 38 #include "options.h" 39 #include "output.h" 40 #include "type.h" 41 #include "value.h" 42 #include "zero.h" 43 44 #define READER(NAME, TYPE) \ 45 static int \ 46 NAME(struct value *value, TYPE *ret, struct value_dict *arguments) \ 47 { \ 48 union { \ 49 TYPE val; \ 50 unsigned char buf[0]; \ 51 } u; \ 52 if (value_extract_buf(value, u.buf, arguments) < 0) \ 53 return -1; \ 54 *ret = u.val; \ 55 return 0; \ 56 } 57 58 READER(read_float, float) 59 READER(read_double, double) 60 61 #undef READER 62 63 #define HANDLE_WIDTH(BITS) \ 64 do { \ 65 long l; \ 66 if (value_extract_word(value, &l, arguments) < 0) \ 67 return -1; \ 68 int##BITS##_t i = l; \ 69 uint64_t v = (uint64_t)(uint##BITS##_t)i; \ 70 switch (format) { \ 71 case INT_FMT_unknown: \ 72 if (l < -10000 || l > 10000) \ 73 case INT_FMT_x: \ 74 return fprintf(stream, "%#"PRIx64, v); \ 75 case INT_FMT_i: \ 76 case INT_FMT_default: \ 77 return fprintf(stream, "%"PRIi##BITS, i); \ 78 case INT_FMT_u: \ 79 return fprintf(stream, "%"PRIu64, v); \ 80 case INT_FMT_o: \ 81 return fprintf(stream, "0%"PRIo64, v); \ 82 } \ 83 } while (0) 84 85 enum int_fmt_t 86 { 87 INT_FMT_i, 88 INT_FMT_u, 89 INT_FMT_o, 90 INT_FMT_x, 91 INT_FMT_unknown, 92 INT_FMT_default, 93 }; 94 95 static int 96 format_integer(FILE *stream, struct value *value, enum int_fmt_t format, 97 struct value_dict *arguments) 98 { 99 switch (type_sizeof(value->inferior, value->type)) { 100 101 case 1: HANDLE_WIDTH(8); 102 case 2: HANDLE_WIDTH(16); 103 case 4: HANDLE_WIDTH(32); 104 case 8: HANDLE_WIDTH(64); 105 106 default: 107 assert(!"unsupported integer width"); 108 abort(); 109 110 case -1: 111 return -1; 112 } 113 } 114 115 #undef HANDLE_WIDTH 116 117 static int 118 acc_fprintf(int *countp, FILE *stream, const char *format, ...) 119 { 120 va_list pa; 121 va_start(pa, format); 122 int i = account_output(countp, vfprintf(stream, format, pa)); 123 va_end(pa); 124 125 return i; 126 } 127 128 static int 129 print_char(FILE *stream, int c) 130 { 131 const char *fmt; 132 switch (c) { 133 case -1: 134 fmt = "EOF"; 135 break; 136 case 0: 137 fmt = "\\0"; 138 break; 139 case '\a': 140 fmt = "\\a"; 141 break; 142 case '\b': 143 fmt = "\\b"; 144 break; 145 case '\t': 146 fmt = "\\t"; 147 break; 148 case '\n': 149 fmt = "\\n"; 150 break; 151 case '\v': 152 fmt = "\\v"; 153 break; 154 case '\f': 155 fmt = "\\f"; 156 break; 157 case '\r': 158 fmt = "\\r"; 159 break; 160 case '\\': 161 fmt = "\\\\"; 162 break; 163 default: 164 if (isprint(c) || c == ' ') 165 fmt = "%c"; 166 else 167 fmt = "\\%03o"; 168 } 169 170 return fprintf(stream, fmt, c); 171 } 172 173 static int 174 format_char(FILE *stream, struct value *value, struct value_dict *arguments) 175 { 176 long lc; 177 if (value_extract_word(value, &lc, arguments) < 0) 178 return -1; 179 return print_char(stream, (int) lc); 180 } 181 182 static int 183 format_naked(FILE *stream, struct value *value, 184 struct value_dict *arguments, 185 int (*what)(FILE *, struct value *, struct value_dict *)) 186 { 187 int written = 0; 188 if (acc_fprintf(&written, stream, "'") < 0 189 || account_output(&written, 190 what(stream, value, arguments)) < 0 191 || acc_fprintf(&written, stream, "'") < 0) 192 return -1; 193 194 return written; 195 } 196 197 static int 198 format_double(FILE *stream, double value, enum int_fmt_t format) 199 { 200 if (format == INT_FMT_x) 201 return fprintf(stream, "%a", value); 202 else 203 return fprintf(stream, "%f", value); 204 } 205 206 static int 207 format_floating(FILE *stream, struct value *value, struct value_dict *arguments, 208 enum int_fmt_t format) 209 { 210 switch (value->type->type) { 211 float f; 212 double d; 213 case ARGTYPE_FLOAT: 214 if (read_float(value, &f, arguments) < 0) 215 return -1; 216 return format_double(stream, f, format); 217 case ARGTYPE_DOUBLE: 218 if (read_double(value, &d, arguments) < 0) 219 return -1; 220 return format_double(stream, d, format); 221 default: 222 abort(); 223 } 224 } 225 226 struct format_argument_data 227 { 228 struct value *value; 229 struct value_dict *arguments; 230 }; 231 232 static int 233 format_argument_cb(FILE *stream, void *ptr) 234 { 235 struct format_argument_data *data = ptr; 236 return format_argument(stream, data->value, data->arguments); 237 } 238 239 static int 240 format_struct(FILE *stream, struct value *value, struct value_dict *arguments) 241 { 242 int written = 0; 243 if (acc_fprintf(&written, stream, "{ ") < 0) 244 return -1; 245 246 int need_delim = 0; 247 size_t i; 248 for (i = 0; i < type_struct_size(value->type); ++i) { 249 struct value element; 250 if (value_init_element(&element, value, i) < 0) 251 return -1; 252 253 struct format_argument_data data = { &element, arguments }; 254 int o = delim_output(stream, &need_delim, 255 format_argument_cb, &data); 256 value_destroy(&element); 257 if (o < 0) 258 return -1; 259 260 written += o; 261 } 262 if (acc_fprintf(&written, stream, " }") < 0) 263 return -1; 264 return written; 265 } 266 267 static const char null_message[] = "nil"; 268 int 269 format_pointer(FILE *stream, struct value *value, struct value_dict *arguments) 270 { 271 if (value_is_zero(value, arguments)) 272 return fprintf(stream, null_message); 273 274 /* The following is for detecting recursion. We keep track of 275 * the values that were already displayed. Each time a 276 * pointer should be dereferenced, we compare its value to the 277 * value of each of the pointers dereferenced so far. If one 278 * of them matches, instead of recursing, we just printf which 279 * superstructure this pointer recurses to. */ 280 static struct vect pointers = {}; 281 if (pointers.elt_size == 0) 282 VECT_INIT(&pointers, struct value *); 283 284 /* Trim number of expanded structures of the same type. Even 285 * for non-recursive structure, we don't want to expand all of 286 * it if it's huge. */ 287 size_t i; 288 size_t len = vect_size(&pointers); 289 assert(value->type->type == ARGTYPE_POINTER); 290 struct arg_type_info *pointee = value->type->u.ptr_info.info; 291 if (pointee->type == ARGTYPE_STRUCT) { 292 size_t depth = 0; 293 for (i = 0; i < len; ++i) { 294 struct value *old 295 = *VECT_ELEMENT(&pointers, struct value *, i); 296 assert(old->type->type == ARGTYPE_POINTER); 297 struct arg_type_info *old_pointee 298 = old->type->u.ptr_info.info; 299 if (old_pointee == pointee) 300 depth++; 301 } 302 if (depth >= options.arraylen) 303 return fprintf(stream, "..."); 304 } 305 306 for (i = len; i-- > 0 ;) { 307 struct value **old = VECT_ELEMENT(&pointers, struct value *, i); 308 int rc = value_equal(value, *old, arguments); 309 if (rc < 0) 310 return -1; 311 if (rc > 0) { 312 size_t reclevel = len - i - 1; 313 char buf[reclevel + 1]; 314 memset(buf, '^', sizeof buf); 315 buf[reclevel] = 0; 316 return fprintf(stream, "recurse%s", buf); 317 } 318 } 319 320 /* OK, not a recursion. Remember this value for tracking. */ 321 if (VECT_PUSHBACK(&pointers, &value) < 0) 322 return -1; 323 324 struct value element; 325 int o; 326 if (value_init_deref(&element, value) < 0) { 327 o = -1; 328 goto done; 329 } 330 o = format_argument(stream, &element, arguments); 331 value_destroy(&element); 332 333 done: 334 VECT_POPBACK(&pointers, struct value *, NULL, NULL); 335 return o; 336 } 337 338 /* 339 * LENGTH is an expression whose evaluation will yield the actual 340 * length of the array. 341 * 342 * MAXLEN is the actual maximum length that we care about 343 * 344 * BEFORE if LENGTH>MAXLEN, we display ellipsis. We display it before 345 * the closing parenthesis if BEFORE, otherwise after it. 346 * 347 * OPEN, CLOSE, DELIM are opening and closing parenthesis and element 348 * delimiter. 349 */ 350 static int 351 format_array(FILE *stream, struct value *value, struct value_dict *arguments, 352 struct expr_node *length, size_t maxlen, int before, 353 const char *open, const char *close, const char *delim) 354 { 355 /* We need "long" to be long enough to cover the whole address 356 * space. */ 357 (void)sizeof(char[1 - 2*(sizeof(long) < sizeof(void *))]); 358 long l; 359 if (expr_eval_word(length, value, arguments, &l) < 0) 360 return -1; 361 size_t len = (size_t)l; 362 363 int written = 0; 364 if (acc_fprintf(&written, stream, "%s", open) < 0) 365 return -1; 366 367 size_t i; 368 for (i = 0; i < len && i <= maxlen; ++i) { 369 if (i == maxlen) { 370 if (before && acc_fprintf(&written, stream, "...") < 0) 371 return -1; 372 break; 373 } 374 375 if (i > 0 && acc_fprintf(&written, stream, "%s", delim) < 0) 376 return -1; 377 378 struct value element; 379 if (value_init_element(&element, value, i) < 0) 380 return -1; 381 int o = format_argument(stream, &element, arguments); 382 value_destroy(&element); 383 if (o < 0) 384 return -1; 385 written += o; 386 } 387 if (acc_fprintf(&written, stream, "%s", close) < 0) 388 return -1; 389 if (i == maxlen && !before && acc_fprintf(&written, stream, "...") < 0) 390 return -1; 391 392 return written; 393 } 394 395 static int 396 toplevel_format_lens(struct lens *lens, FILE *stream, 397 struct value *value, struct value_dict *arguments, 398 enum int_fmt_t int_fmt) 399 { 400 switch (value->type->type) { 401 case ARGTYPE_VOID: 402 return fprintf(stream, "<void>"); 403 404 case ARGTYPE_SHORT: 405 case ARGTYPE_INT: 406 case ARGTYPE_LONG: 407 return format_integer(stream, value, int_fmt, arguments); 408 409 case ARGTYPE_USHORT: 410 case ARGTYPE_UINT: 411 case ARGTYPE_ULONG: 412 if (int_fmt == INT_FMT_i || int_fmt == INT_FMT_default) 413 int_fmt = INT_FMT_u; 414 return format_integer(stream, value, int_fmt, arguments); 415 416 case ARGTYPE_CHAR: 417 if (int_fmt == INT_FMT_default) 418 return format_naked(stream, value, arguments, 419 &format_char); 420 return format_integer(stream, value, int_fmt, arguments); 421 422 case ARGTYPE_FLOAT: 423 case ARGTYPE_DOUBLE: 424 return format_floating(stream, value, arguments, int_fmt); 425 426 case ARGTYPE_STRUCT: 427 return format_struct(stream, value, arguments); 428 429 case ARGTYPE_POINTER: 430 if (value_is_zero(value, arguments)) 431 return fprintf(stream, null_message); 432 if (value->type->u.array_info.elt_type->type != ARGTYPE_VOID) 433 return format_pointer(stream, value, arguments); 434 return format_integer(stream, value, INT_FMT_x, arguments); 435 436 case ARGTYPE_ARRAY: 437 return format_array(stream, value, arguments, 438 value->type->u.array_info.length, 439 options.arraylen, 1, "[ ", " ]", ", "); 440 } 441 abort(); 442 } 443 444 static int 445 default_lens_format_cb(struct lens *lens, FILE *stream, 446 struct value *value, struct value_dict *arguments) 447 { 448 return toplevel_format_lens(lens, stream, value, arguments, 449 INT_FMT_default); 450 } 451 452 struct lens default_lens = { 453 .format_cb = default_lens_format_cb, 454 }; 455 456 457 static int 458 blind_lens_format_cb(struct lens *lens, FILE *stream, 459 struct value *value, struct value_dict *arguments) 460 { 461 return 0; 462 } 463 464 struct lens blind_lens = { 465 .format_cb = blind_lens_format_cb, 466 }; 467 468 469 static int 470 octal_lens_format_cb(struct lens *lens, FILE *stream, 471 struct value *value, struct value_dict *arguments) 472 { 473 return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_o); 474 } 475 476 struct lens octal_lens = { 477 .format_cb = octal_lens_format_cb, 478 }; 479 480 481 static int 482 hex_lens_format_cb(struct lens *lens, FILE *stream, 483 struct value *value, struct value_dict *arguments) 484 { 485 return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_x); 486 } 487 488 struct lens hex_lens = { 489 .format_cb = hex_lens_format_cb, 490 }; 491 492 493 static int 494 dec_lens_format_cb(struct lens *lens, FILE *stream, 495 struct value *value, struct value_dict *arguments) 496 { 497 return toplevel_format_lens(lens, stream, value, arguments, INT_FMT_u); 498 } 499 500 struct lens dec_lens = { 501 .format_cb = dec_lens_format_cb, 502 }; 503 504 505 static int 506 guess_lens_format_cb(struct lens *lens, FILE *stream, 507 struct value *value, struct value_dict *arguments) 508 { 509 return toplevel_format_lens(lens, stream, value, arguments, 510 INT_FMT_unknown); 511 } 512 513 struct lens guess_lens = { 514 .format_cb = guess_lens_format_cb, 515 }; 516 517 518 static int 519 bool_lens_format_cb(struct lens *lens, FILE *stream, 520 struct value *value, struct value_dict *arguments) 521 { 522 switch (value->type->type) { 523 case ARGTYPE_VOID: 524 case ARGTYPE_FLOAT: 525 case ARGTYPE_DOUBLE: 526 case ARGTYPE_STRUCT: 527 case ARGTYPE_POINTER: 528 case ARGTYPE_ARRAY: 529 return toplevel_format_lens(lens, stream, value, 530 arguments, INT_FMT_default); 531 532 int zero; 533 case ARGTYPE_SHORT: 534 case ARGTYPE_INT: 535 case ARGTYPE_LONG: 536 case ARGTYPE_USHORT: 537 case ARGTYPE_UINT: 538 case ARGTYPE_ULONG: 539 case ARGTYPE_CHAR: 540 if ((zero = value_is_zero(value, arguments)) < 0) 541 return -1; 542 if (zero) 543 return fprintf(stream, "false"); 544 else 545 return fprintf(stream, "true"); 546 } 547 abort(); 548 } 549 550 struct lens bool_lens = { 551 .format_cb = bool_lens_format_cb, 552 }; 553 554 static int 555 redispatch_as_array(struct lens *lens, FILE *stream, 556 struct value *value, struct value_dict *arguments, 557 int (*cb)(struct lens *, FILE *, 558 struct value *, struct value_dict *)) 559 { 560 struct arg_type_info info[2]; 561 type_init_array(&info[1], value->type->u.ptr_info.info, 0, 562 expr_node_zero(), 0); 563 type_init_pointer(&info[0], &info[1], 0); 564 info->lens = lens; 565 info->own_lens = 0; 566 struct value tmp; 567 if (value_clone(&tmp, value) < 0) 568 return -1; 569 value_set_type(&tmp, info, 0); 570 int ret = cb(lens, stream, &tmp, arguments); 571 type_destroy(&info[0]); 572 type_destroy(&info[1]); 573 value_destroy(&tmp); 574 return ret; 575 } 576 577 static int 578 format_wchar(FILE *stream, struct value *value, struct value_dict *arguments) 579 { 580 long l; 581 if (value_extract_word(value, &l, arguments) < 0) 582 return -1; 583 wchar_t wc = (wchar_t) l; 584 char buf[MB_CUR_MAX + 1]; 585 586 int c = wctomb(buf, wc); 587 if (c < 0) 588 return -1; 589 if (c == 1) 590 return print_char(stream, buf[0]); 591 592 buf[c] = 0; 593 if (fprintf(stream, "%s", buf) < 0) 594 return -1; 595 596 c = wcwidth(wc); 597 return c >= 0 ? c : 0; 598 } 599 600 static int 601 string_lens_format_cb(struct lens *lens, FILE *stream, 602 struct value *value, struct value_dict *arguments) 603 { 604 switch (value->type->type) { 605 case ARGTYPE_POINTER: 606 /* This should really be written as either "string", 607 * or, if lens, then string(array(char, zero)*). But 608 * I suspect people are so used to the char * C idiom, 609 * that string(char *) might actually turn up. So 610 * let's just support it. */ 611 switch ((int) value->type->u.ptr_info.info->type) 612 case ARGTYPE_CHAR: 613 case ARGTYPE_SHORT: 614 case ARGTYPE_USHORT: 615 case ARGTYPE_INT: 616 case ARGTYPE_UINT: 617 case ARGTYPE_LONG: 618 case ARGTYPE_ULONG: 619 return redispatch_as_array(lens, stream, value, 620 arguments, 621 &string_lens_format_cb); 622 623 /* Otherwise dispatch to whatever the default for the 624 * pointee is--most likely this will again be us. */ 625 /* Fall through. */ 626 case ARGTYPE_VOID: 627 case ARGTYPE_FLOAT: 628 case ARGTYPE_DOUBLE: 629 case ARGTYPE_STRUCT: 630 return toplevel_format_lens(lens, stream, value, 631 arguments, INT_FMT_default); 632 633 case ARGTYPE_SHORT: 634 case ARGTYPE_INT: 635 case ARGTYPE_LONG: 636 case ARGTYPE_USHORT: 637 case ARGTYPE_UINT: 638 case ARGTYPE_ULONG: 639 if (value->parent != NULL && value->type->lens == NULL) 640 return format_wchar(stream, value, arguments); 641 else 642 return format_naked(stream, value, arguments, 643 &format_wchar); 644 645 case ARGTYPE_CHAR: 646 return format_char(stream, value, arguments); 647 648 case ARGTYPE_ARRAY: 649 return format_array(stream, value, arguments, 650 value->type->u.array_info.length, 651 options.strlen, 0, "\"", "\"", ""); 652 } 653 abort(); 654 } 655 656 struct lens string_lens = { 657 .format_cb = string_lens_format_cb, 658 }; 659 660 static int 661 out_bits(FILE *stream, size_t low, size_t high) 662 { 663 if (low == high) 664 return fprintf(stream, "%zd", low); 665 else 666 return fprintf(stream, "%zd-%zd", low, high); 667 } 668 669 static int 670 bitvect_lens_format_cb(struct lens *lens, FILE *stream, 671 struct value *value, struct value_dict *arguments) 672 { 673 unsigned char *data = value_get_data(value, arguments); 674 if (data == NULL) 675 return -1; 676 size_t sz = type_sizeof(value->inferior, value->type); 677 if (sz == (size_t)-1) 678 return -1; 679 680 size_t i; 681 unsigned char buf[sz]; 682 switch ((int)value->type->type) { 683 union bitvect_integral_64 684 { 685 uint8_t u8; 686 uint16_t u16; 687 uint32_t u32; 688 uint64_t u64; 689 unsigned char buf[0]; 690 } bv; 691 692 case ARGTYPE_POINTER: 693 return format_pointer(stream, value, arguments); 694 695 case ARGTYPE_STRUCT: 696 case ARGTYPE_ARRAY: 697 break; 698 699 default: 700 assert(sz <= sizeof(bv)); 701 memmove(bv.buf, data, sz); 702 703 if (sz == 1) 704 bv.u64 = bv.u8; 705 else if (sz == 2) 706 bv.u64 = bv.u16; 707 else if (sz == 4) 708 bv.u64 = bv.u32; 709 710 for (i = 0; i < sz; ++i) { 711 buf[i] = bv.u64 & 0xff; 712 bv.u64 >>= 8; 713 } 714 data = buf; 715 } 716 717 size_t bits = 0; 718 for (i = 0; i < sz; ++i) 719 bits += bitcount(data[i]); 720 721 /* If there's more 1's than 0's, show inverse. */ 722 unsigned neg = bits > sz * 4 ? 0xff : 0x00; 723 724 int o = 0; 725 if (acc_fprintf(&o, stream, "%s<", &"~"[neg == 0x00]) < 0) 726 return -1; 727 728 size_t bitno = 0; 729 ssize_t low = -1; 730 for (i = 0; i < sz; ++i) { 731 unsigned char m; 732 unsigned char d = data[i] ^ neg; 733 for (m = 0x01; m != 0; m <<= 1) { 734 int bit = !!(m & d); 735 if (low < 0) { 736 if (bit) { 737 if (low == -2 738 && acc_fprintf(&o, stream, ",") < 0) 739 return -1; 740 low = bitno; 741 } 742 } else if (!bit) { 743 if (account_output(&o, out_bits(stream, low, 744 bitno-1)) < 0) 745 return -1; 746 low = -2; 747 } 748 bitno++; 749 } 750 } 751 if (low >= 0 && account_output(&o, out_bits(stream, low, bitno-1)) < 0) 752 return -1; 753 754 if (fputc('>', stream) < 0) 755 return -1; 756 o += 1; 757 758 return o; 759 } 760 761 struct lens bitvect_lens = { 762 .format_cb = bitvect_lens_format_cb, 763 }; 764
