type.c

   1 /*
   2  * This file is part of ltrace.
   3  * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc.
   4  * Copyright (C) 2007,2008 Juan Cespedes
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  19  * 02110-1301 USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #include <limits.h>
  25
  26 #include "type.h"
  27 #include "sysdep.h"
  28 #include "expr.h"
  29 #include "lens.h"
  30
  31 struct arg_type_info *
  32 type_get_simple(enum arg_type type)
  33 {
  34 #define HANDLE(T) {                                     \
  35                 static struct arg_type_info t = { T };  \
  36         case T:                                         \
  37                 return &t;                              \
  38         }
  39
  40         switch (type) {
  41         HANDLE(ARGTYPE_VOID)
  42         HANDLE(ARGTYPE_INT)
  43         HANDLE(ARGTYPE_UINT)
  44         HANDLE(ARGTYPE_LONG)
  45         HANDLE(ARGTYPE_ULONG)
  46         HANDLE(ARGTYPE_CHAR)
  47         HANDLE(ARGTYPE_SHORT)
  48         HANDLE(ARGTYPE_USHORT)
  49         HANDLE(ARGTYPE_FLOAT)
  50         HANDLE(ARGTYPE_DOUBLE)
  51
  52 #undef HANDLE
  53
  54         case ARGTYPE_ARRAY:
  55         case ARGTYPE_STRUCT:
  56         case ARGTYPE_POINTER:
  57                 assert(!"Not a simple type!");
  58         };
  59         abort();
  60 }
  61
  62 struct arg_type_info *
  63 type_get_voidptr(void)
  64 {
  65         struct arg_type_info *void_info = type_get_simple(ARGTYPE_VOID);
  66         static struct arg_type_info *ret;
  67         if (ret == NULL) {
  68                 static struct arg_type_info ptr_info;
  69                 type_init_pointer(&ptr_info, void_info, 0);
  70                 ret = &ptr_info;
  71         }
  72         return ret;
  73 }
  74
  75 static void
  76 type_init_common(struct arg_type_info *info, enum arg_type type)
  77 {
  78         info->type = type;
  79         info->lens = NULL;
  80         info->own_lens = 0;
  81 }
  82
  83 struct struct_field {
  84         struct arg_type_info *info;
  85         int own_info;
  86 };
  87
  88 void
  89 type_init_struct(struct arg_type_info *info)
  90 {
  91         type_init_common(info, ARGTYPE_STRUCT);
  92         VECT_INIT(&info->u.entries, struct struct_field);
  93 }
  94
  95 int
  96 type_struct_add(struct arg_type_info *info,
  97                 struct arg_type_info *field_info, int own)
  98 {
  99         assert(info->type == ARGTYPE_STRUCT);
 100         struct struct_field field = { field_info, own };
 101         return VECT_PUSHBACK(&info->u.entries, &field);
 102 }
 103
 104 struct arg_type_info *
 105 type_struct_get(struct arg_type_info *info, size_t idx)
 106 {
 107         assert(info->type == ARGTYPE_STRUCT);
 108         return VECT_ELEMENT(&info->u.entries, struct struct_field, idx)->info;
 109 }
 110
 111 size_t
 112 type_struct_size(struct arg_type_info *info)
 113 {
 114         assert(info->type == ARGTYPE_STRUCT);
 115         return vect_size(&info->u.entries);
 116 }
 117
 118 static void
 119 struct_field_dtor(struct struct_field *field, void *data)
 120 {
 121         if (field->own_info) {
 122                 type_destroy(field->info);
 123                 free(field->info);
 124         }
 125 }
 126
 127 static void
 128 type_struct_destroy(struct arg_type_info *info)
 129 {
 130         VECT_DESTROY(&info->u.entries, struct struct_field,
 131                      struct_field_dtor, NULL);
 132 }
 133
 134 static int
 135 layout_struct(struct process *proc, struct arg_type_info *info,
 136               size_t *sizep, size_t *alignmentp, size_t *offsetofp)
 137 {
 138         size_t sz = 0;
 139         size_t max_alignment = 0;
 140         size_t i;
 141         size_t offsetof_field = (size_t)-1;
 142         if (offsetofp != NULL)
 143                 offsetof_field = *offsetofp;
 144
 145         assert(info->type == ARGTYPE_STRUCT);
 146         for (i = 0; i < vect_size(&info->u.entries); ++i) {
 147                 struct struct_field *field
 148                         = VECT_ELEMENT(&info->u.entries,
 149                                        struct struct_field, i);
 150
 151                 size_t alignment = type_alignof(proc, field->info);
 152                 if (alignment == (size_t)-1)
 153                         return -1;
 154
 155                 /* Add padding to SZ to align the next element.  */
 156                 sz = align(sz, alignment);
 157                 if (i == offsetof_field) {
 158                         *offsetofp = sz;
 159                         if (sizep == NULL && alignmentp == NULL)
 160                                 return 0;
 161                 }
 162
 163                 size_t size = type_sizeof(proc, field->info);
 164                 if (size == (size_t)-1)
 165                         return -1;
 166                 sz += size;
 167
 168                 if (alignment > max_alignment)
 169                         max_alignment = alignment;
 170         }
 171
 172         if (max_alignment > 0)
 173                 sz = align(sz, max_alignment);
 174
 175         if (sizep != NULL)
 176                 *sizep = sz;
 177
 178         if (alignmentp != NULL)
 179                 *alignmentp = max_alignment;
 180
 181         return 0;
 182 }
 183
 184 void
 185 type_init_array(struct arg_type_info *info,
 186                 struct arg_type_info *element_info, int own_info,
 187                 struct expr_node *length_expr, int own_length)
 188 {
 189         type_init_common(info, ARGTYPE_ARRAY);
 190         info->u.array_info.elt_type = element_info;
 191         info->u.array_info.own_info = own_info;
 192         info->u.array_info.length = length_expr;
 193         info->u.array_info.own_length = own_length;
 194 }
 195
 196 static void
 197 type_array_destroy(struct arg_type_info *info)
 198 {
 199         if (info->u.array_info.own_info) {
 200                 type_destroy(info->u.array_info.elt_type);
 201                 free(info->u.array_info.elt_type);
 202         }
 203         if (info->u.array_info.own_length) {
 204                 expr_destroy(info->u.array_info.length);
 205                 free(info->u.array_info.length);
 206         }
 207 }
 208
 209 void
 210 type_init_pointer(struct arg_type_info *info,
 211                   struct arg_type_info *pointee_info, int own_info)
 212 {
 213         type_init_common(info, ARGTYPE_POINTER);
 214         info->u.ptr_info.info = pointee_info;
 215         info->u.ptr_info.own_info = own_info;
 216 }
 217
 218 static void
 219 type_pointer_destroy(struct arg_type_info *info)
 220 {
 221         if (info->u.ptr_info.own_info) {
 222                 type_destroy(info->u.ptr_info.info);
 223                 free(info->u.ptr_info.info);
 224         }
 225 }
 226
 227 void
 228 type_destroy(struct arg_type_info *info)
 229 {
 230         if (info == NULL)
 231                 return;
 232
 233         switch (info->type) {
 234         case ARGTYPE_STRUCT:
 235                 type_struct_destroy(info);
 236                 break;
 237
 238         case ARGTYPE_ARRAY:
 239                 type_array_destroy(info);
 240                 break;
 241
 242         case ARGTYPE_POINTER:
 243                 type_pointer_destroy(info);
 244                 break;
 245
 246         case ARGTYPE_VOID:
 247         case ARGTYPE_INT:
 248         case ARGTYPE_UINT:
 249         case ARGTYPE_LONG:
 250         case ARGTYPE_ULONG:
 251         case ARGTYPE_CHAR:
 252         case ARGTYPE_SHORT:
 253         case ARGTYPE_USHORT:
 254         case ARGTYPE_FLOAT:
 255         case ARGTYPE_DOUBLE:
 256                 break;
 257         }
 258
 259         if (info->own_lens) {
 260                 lens_destroy(info->lens);
 261                 free(info->lens);
 262         }
 263 }
 264
 265 static int
 266 type_alloc_and_clone(struct arg_type_info **retpp,
 267                      struct arg_type_info *info, int own)
 268 {
 269         *retpp = info;
 270         if (own) {
 271                 *retpp = malloc(sizeof **retpp);
 272                 if (*retpp == NULL || type_clone(*retpp, info) < 0) {
 273                         free(*retpp);
 274                         return -1;
 275                 }
 276         }
 277         return 0;
 278 }
 279
 280 static enum callback_status
 281 clone_struct_add_field(const struct struct_field *field, void *data)
 282 {
 283         struct arg_type_info *retp = data;
 284         struct arg_type_info *info;
 285         if (type_alloc_and_clone(&info, field->info, field->own_info) < 0) {
 286         fail:
 287                 if (info != field->info)
 288                         free(info);
 289                 return CBS_STOP;
 290         }
 291
 292         if (type_struct_add(retp, info, field->own_info) < 0) {
 293                 if (field->own_info)
 294                         type_destroy(info);
 295                 goto fail;
 296         }
 297
 298         return CBS_CONT;
 299 }
 300
 301 int
 302 type_clone(struct arg_type_info *retp, const struct arg_type_info *info)
 303 {
 304         switch (info->type) {
 305         case ARGTYPE_STRUCT:
 306                 type_init_struct(retp);
 307                 if (VECT_EACH_CST(&info->u.entries, struct struct_field, NULL,
 308                                   clone_struct_add_field, retp) != NULL) {
 309                         type_destroy(retp);
 310                         return -1;
 311                 }
 312                 break;
 313
 314         case ARGTYPE_ARRAY:;
 315                 struct arg_type_info *elt_type;
 316                 if (type_alloc_and_clone(&elt_type, info->u.array_info.elt_type,
 317                                          info->u.array_info.own_info) < 0)
 318                         return -1;
 319
 320                 assert(!info->u.array_info.own_length); // XXXXXXX
 321                 type_init_array(retp, elt_type, info->u.array_info.own_info,
 322                                 info->u.array_info.length,
 323                                 info->u.array_info.own_length);
 324                 break;
 325
 326         case ARGTYPE_POINTER:;
 327                 struct arg_type_info *ninfo;
 328                 if (type_alloc_and_clone(&ninfo, info->u.ptr_info.info,
 329                                          info->u.ptr_info.own_info) < 0)
 330                         return -1;
 331                 type_init_pointer(retp, ninfo, info->u.ptr_info.own_info);
 332                 break;
 333
 334         case ARGTYPE_VOID:
 335         case ARGTYPE_INT:
 336         case ARGTYPE_UINT:
 337         case ARGTYPE_LONG:
 338         case ARGTYPE_ULONG:
 339         case ARGTYPE_CHAR:
 340         case ARGTYPE_SHORT:
 341         case ARGTYPE_USHORT:
 342         case ARGTYPE_FLOAT:
 343         case ARGTYPE_DOUBLE:
 344                 *retp = *info;
 345                 break;
 346         }
 347
 348         assert(!info->own_lens);
 349         retp->lens = info->lens;
 350         retp->own_lens = info->own_lens;
 351         return 0;
 352 }
 353
 354 #ifdef ARCH_HAVE_SIZEOF
 355 size_t arch_type_sizeof(struct process *proc, struct arg_type_info *arg);
 356 #else
 357 size_t
 358 arch_type_sizeof(struct process *proc, struct arg_type_info *arg)
 359 {
 360         /* Use default value.  */
 361         return (size_t)-2;
 362 }
 363 #endif
 364
 365 #ifdef ARCH_HAVE_ALIGNOF
 366 size_t arch_type_alignof(struct process *proc, struct arg_type_info *arg);
 367 #else
 368 size_t
 369 arch_type_alignof(struct process *proc, struct arg_type_info *arg)
 370 {
 371         /* Use default value.  */
 372         return (size_t)-2;
 373 }
 374 #endif
 375
 376 /* We need to support alignments that are not power of two.  E.g. long
 377  * double on x86 has alignment of 12.  */
 378 size_t
 379 align(size_t sz, size_t alignment)
 380 {
 381         assert(alignment != 0);
 382
 383         if ((sz % alignment) != 0)
 384                 sz = ((sz / alignment) + 1) * alignment;
 385
 386         return sz;
 387 }
 388
 389 size_t
 390 type_sizeof(struct process *proc, struct arg_type_info *type)
 391 {
 392         size_t arch_size = arch_type_sizeof(proc, type);
 393         if (arch_size != (size_t)-2)
 394                 return arch_size;
 395
 396         switch (type->type) {
 397                 size_t size;
 398         case ARGTYPE_CHAR:
 399                 return sizeof(char);
 400
 401         case ARGTYPE_SHORT:
 402         case ARGTYPE_USHORT:
 403                 return sizeof(short);
 404
 405         case ARGTYPE_INT:
 406         case ARGTYPE_UINT:
 407                 return sizeof(int);
 408
 409         case ARGTYPE_LONG:
 410         case ARGTYPE_ULONG:
 411                 return sizeof(long);
 412
 413         case ARGTYPE_FLOAT:
 414                 return sizeof(float);
 415
 416         case ARGTYPE_DOUBLE:
 417                 return sizeof(double);
 418
 419         case ARGTYPE_STRUCT:
 420                 if (layout_struct(proc, type, &size, NULL, NULL) < 0)
 421                         return (size_t)-1;
 422                 return size;
 423
 424         case ARGTYPE_POINTER:
 425                 return sizeof(void *);
 426
 427         case ARGTYPE_ARRAY:
 428                 if (expr_is_compile_constant(type->u.array_info.length)) {
 429                         long l;
 430                         if (expr_eval_constant(type->u.array_info.length,
 431                                                &l) < 0)
 432                                 return -1;
 433
 434                         struct arg_type_info *elt_ti
 435                                 = type->u.array_info.elt_type;
 436
 437                         size_t elt_size = type_sizeof(proc, elt_ti);
 438                         if (elt_size == (size_t)-1)
 439                                 return (size_t)-1;
 440
 441                         return ((size_t)l) * elt_size;
 442
 443                 } else {
 444                         /* Flexible arrays don't count into the
 445                          * sizeof.  */
 446                         return 0;
 447                 }
 448
 449         case ARGTYPE_VOID:
 450                 return 0;
 451         }
 452
 453         abort();
 454 }
 455
 456 #undef alignof
 457 #define alignof(field,st) ((size_t) ((char*) &st.field - (char*) &st))
 458
 459 size_t
 460 type_alignof(struct process *proc, struct arg_type_info *type)
 461 {
 462         size_t arch_alignment = arch_type_alignof(proc, type);
 463         if (arch_alignment != (size_t)-2)
 464                 return arch_alignment;
 465
 466         struct { char c; char C; } cC;
 467         struct { char c; short s; } cs;
 468         struct { char c; int i; } ci;
 469         struct { char c; long l; } cl;
 470         struct { char c; void* p; } cp;
 471         struct { char c; float f; } cf;
 472         struct { char c; double d; } cd;
 473
 474         static size_t char_alignment = alignof(C, cC);
 475         static size_t short_alignment = alignof(s, cs);
 476         static size_t int_alignment = alignof(i, ci);
 477         static size_t long_alignment = alignof(l, cl);
 478         static size_t ptr_alignment = alignof(p, cp);
 479         static size_t float_alignment = alignof(f, cf);
 480         static size_t double_alignment = alignof(d, cd);
 481
 482         switch (type->type) {
 483                 size_t alignment;
 484         case ARGTYPE_LONG:
 485         case ARGTYPE_ULONG:
 486                 return long_alignment;
 487         case ARGTYPE_CHAR:
 488                 return char_alignment;
 489         case ARGTYPE_SHORT:
 490         case ARGTYPE_USHORT:
 491                 return short_alignment;
 492         case ARGTYPE_FLOAT:
 493                 return float_alignment;
 494         case ARGTYPE_DOUBLE:
 495                 return double_alignment;
 496         case ARGTYPE_POINTER:
 497                 return ptr_alignment;
 498
 499         case ARGTYPE_ARRAY:
 500                 return type_alignof(proc, type->u.array_info.elt_type);
 501
 502         case ARGTYPE_STRUCT:
 503                 if (layout_struct(proc, type, NULL, &alignment, NULL) < 0)
 504                         return (size_t)-1;
 505                 return alignment;
 506
 507         default:
 508                 return int_alignment;
 509         }
 510 }
 511
 512 size_t
 513 type_offsetof(struct process *proc, struct arg_type_info *type, size_t emt)
 514 {
 515         assert(type->type == ARGTYPE_STRUCT
 516                || type->type == ARGTYPE_ARRAY);
 517
 518         switch (type->type) {
 519                 size_t alignment;
 520                 size_t size;
 521         case ARGTYPE_ARRAY:
 522                 alignment = type_alignof(proc, type->u.array_info.elt_type);
 523                 if (alignment == (size_t)-1)
 524                         return (size_t)-1;
 525
 526                 size = type_sizeof(proc, type->u.array_info.elt_type);
 527                 if (size == (size_t)-1)
 528                         return (size_t)-1;
 529
 530                 return emt * align(size, alignment);
 531
 532         case ARGTYPE_STRUCT:
 533                 if (layout_struct(proc, type, NULL, NULL, &emt) < 0)
 534                         return (size_t)-1;
 535                 return emt;
 536
 537         default:
 538                 abort();
 539         }
 540 }
 541
 542 struct arg_type_info *
 543 type_element(struct arg_type_info *info, size_t emt)
 544 {
 545         assert(info->type == ARGTYPE_STRUCT
 546                || info->type == ARGTYPE_ARRAY);
 547
 548         switch (info->type) {
 549         case ARGTYPE_ARRAY:
 550                 return info->u.array_info.elt_type;
 551
 552         case ARGTYPE_STRUCT:
 553                 assert(emt < type_struct_size(info));
 554                 return type_struct_get(info, emt);
 555
 556         default:
 557                 abort();
 558         }
 559 }
 560
 561 size_t
 562 type_aggregate_size(struct arg_type_info *info)
 563 {
 564         assert(info->type == ARGTYPE_STRUCT
 565                || info->type == ARGTYPE_ARRAY);
 566
 567         switch (info->type) {
 568                 long ret;
 569         case ARGTYPE_ARRAY:
 570                 if (expr_eval_constant(info->u.array_info.length, &ret) < 0)
 571                         return (size_t)-1;
 572                 return (size_t)ret;
 573
 574         case ARGTYPE_STRUCT:
 575                 return type_struct_size(info);
 576
 577         default:
 578                 abort();
 579         }
 580 }
 581
 582 int
 583 type_is_integral(enum arg_type type)
 584 {
 585         switch (type) {
 586         case ARGTYPE_INT:
 587         case ARGTYPE_UINT:
 588         case ARGTYPE_LONG:
 589         case ARGTYPE_ULONG:
 590         case ARGTYPE_CHAR:
 591         case ARGTYPE_SHORT:
 592         case ARGTYPE_USHORT:
 593                 return 1;
 594
 595         case ARGTYPE_VOID:
 596         case ARGTYPE_FLOAT:
 597         case ARGTYPE_DOUBLE:
 598         case ARGTYPE_ARRAY:
 599         case ARGTYPE_STRUCT:
 600         case ARGTYPE_POINTER:
 601                 return 0;
 602         }
 603         abort();
 604 }
 605
 606 int
 607 type_is_signed(enum arg_type type)
 608 {
 609         assert(type_is_integral(type));
 610
 611         switch (type) {
 612         case ARGTYPE_CHAR:
 613                 return CHAR_MIN != 0;
 614
 615         case ARGTYPE_SHORT:
 616         case ARGTYPE_INT:
 617         case ARGTYPE_LONG:
 618                 return 1;
 619
 620         case ARGTYPE_UINT:
 621         case ARGTYPE_ULONG:
 622         case ARGTYPE_USHORT:
 623                 return 0;
 624
 625         case ARGTYPE_VOID:
 626         case ARGTYPE_FLOAT:
 627         case ARGTYPE_DOUBLE:
 628         case ARGTYPE_ARRAY:
 629         case ARGTYPE_STRUCT:
 630         case ARGTYPE_POINTER:
 631                 abort();
 632         }
 633         abort();
 634 }
 635
 636 struct arg_type_info *
 637 type_get_fp_equivalent(struct arg_type_info *info)
 638 {
 639         /* Extract innermost structure.  Give up early if any
 640          * component has more than one element.  */
 641         while (info->type == ARGTYPE_STRUCT) {
 642                 if (type_struct_size(info) != 1)
 643                         return NULL;
 644                 info = type_element(info, 0);
 645         }
 646
 647         switch (info->type) {
 648         case ARGTYPE_CHAR:
 649         case ARGTYPE_SHORT:
 650         case ARGTYPE_INT:
 651         case ARGTYPE_LONG:
 652         case ARGTYPE_UINT:
 653         case ARGTYPE_ULONG:
 654         case ARGTYPE_USHORT:
 655         case ARGTYPE_VOID:
 656         case ARGTYPE_ARRAY:
 657         case ARGTYPE_POINTER:
 658                 return NULL;
 659
 660         case ARGTYPE_FLOAT:
 661         case ARGTYPE_DOUBLE:
 662                 return info;
 663
 664         case ARGTYPE_STRUCT:
 665                 abort();
 666         }
 667         abort();
 668 }
 669
 670 struct arg_type_info *
 671 type_get_hfa_type(struct arg_type_info *info, size_t *countp)
 672 {
 673         assert(info != NULL);
 674         if (info->type != ARGTYPE_STRUCT
 675             && info->type != ARGTYPE_ARRAY)
 676                 return NULL;
 677
 678         size_t n = type_aggregate_size(info);
 679         if (n == (size_t)-1)
 680                 return NULL;
 681
 682         struct arg_type_info *ret = NULL;
 683         *countp = 0;
 684
 685         while (n-- > 0) {
 686                 struct arg_type_info *emt = type_element(info, n);
 687
 688                 size_t emt_count = 1;
 689                 if (emt->type == ARGTYPE_STRUCT || emt->type == ARGTYPE_ARRAY)
 690                         emt = type_get_hfa_type(emt, &emt_count);
 691                 if (emt == NULL)
 692                         return NULL;
 693                 if (ret == NULL) {
 694                         if (emt->type != ARGTYPE_FLOAT
 695                             && emt->type != ARGTYPE_DOUBLE)
 696                                 return NULL;
 697                         ret = emt;
 698                 }
 699                 if (emt->type != ret->type)
 700                         return NULL;
 701                 *countp += emt_count;
 702         }
 703         return ret;
 704 }