mono/profiler/decode.c

   1 /*
   2  * decode.c: mprof-report program source: decode and analyze the log profiler data
   3  *
   4  * Authors:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *   Alex Rønne Petersen (alexrp@xamarin.com)
   7  *
   8  * Copyright 2010 Novell, Inc (http://www.novell.com)
   9  */
  10
  11 /*
  12  * The Coverage XML output schema
  13  * <coverage>
  14  *   <assembly/>
  15  *   <class/>
  16  *   <method>
  17  *     <statement/>
  18  *   </method>
  19  * </coverage>
  20  *
  21  * Elements:
  22  *   <coverage> - The root element of the documentation. It can contain any number of
  23  *                <assembly>, <class> or <method> elements.
  24  *                Attributes:
  25  *                   - version: The version number for the file format - (eg: "0.3")
  26  *   <assembly> - Contains data about assemblies. Has no child elements
  27  *                Attributes:
  28  *                   - name: The name of the assembly - (eg: "System.Xml")
  29  *                   - guid: The GUID of the assembly
  30  *                   - filename: The filename of the assembly
  31  *                   - method-count: The number of methods in the assembly
  32  *                   - full: The number of fully covered methods
  33  *                   - partial: The number of partially covered methods
  34  *   <class> - Contains data about classes. Has no child elements
  35  *             Attributes:
  36  *                - name: The name of the class
  37  *                - method-count: The number of methods in the class
  38  *                - full: The number of fully covered methods
  39  *                - partial: The number of partially covered methods
  40  *   <method> - Contains data about methods. Can contain any number of <statement> elements
  41  *              Attributes:
  42  *                 - assembly: The name of the parent assembly
  43  *                 - class: The name of the parent class
  44  *                 - name: The name of the method, with all it's parameters
  45  *                 - filename: The name of the source file containing this method
  46  *                 - token
  47  *   <statement> - Contains data about IL statements. Has no child elements
  48  *                 Attributes:
  49  *                    - offset: The offset of the statement in the IL code after the previous
  50  *                              statement's offset
  51  *                    - counter: 1 if the line was covered, 0 if it was not
  52  *                    - line: The line number in the parent method's file
  53  *                    - column: The column on the line
  54  */
  55 #include <config.h>
  56 #include "utils.c"
  57 #include "proflog.h"
  58 #include <string.h>
  59 #include <assert.h>
  60 #include <stdio.h>
  61 #if !defined(__APPLE__) && !defined(__FreeBSD__)
  62 #include <malloc.h>
  63 #endif
  64 #include <unistd.h>
  65 #include <stdlib.h>
  66 #if defined (HAVE_SYS_ZLIB)
  67 #include <zlib.h>
  68 #endif
  69 #include <glib.h>
  70 #include <mono/metadata/profiler.h>
  71 #include <mono/metadata/object.h>
  72 #include <mono/metadata/debug-helpers.h>
  73 #include <mono/utils/mono-counters.h>
  74
  75 #define HASH_SIZE 9371
  76 #define SMALL_HASH_SIZE 31
  77
  78 #if defined(__native_client__) || defined(__native_client_codegen__)
  79 volatile int __nacl_thread_suspension_needed = 0;
  80 void __nacl_suspend_thread_if_needed() {}
  81 #endif
  82
  83 static int debug = 0;
  84 static int collect_traces = 0;
  85 static int show_traces = 0;
  86 static int trace_max = 6;
  87 static int verbose = 0;
  88 static uintptr_t *tracked_objects = 0;
  89 static int num_tracked_objects = 0;
  90 static uintptr_t thread_filter = 0;
  91 static uint64_t find_size = 0;
  92 static const char* find_name = NULL;
  93 static uint64_t time_from = 0;
  94 static uint64_t time_to = 0xffffffffffffffffULL;
  95 static int use_time_filter = 0;
  96 static uint64_t startup_time = 0;
  97 static FILE* outfile = NULL;
  98 static FILE* coverage_outfile = NULL;
  99
 100 static int32_t
 101 read_int16 (unsigned char *p)
 102 {
 103         int32_t value = *p++;
 104         value |= (*p++) << 8;
 105         return value;
 106 }
 107
 108 static int32_t
 109 read_int32 (unsigned char *p)
 110 {
 111         int32_t value = *p++;
 112         value |= (*p++) << 8;
 113         value |= (*p++) << 16;
 114         value |= (uint32_t)(*p++) << 24;
 115         return value;
 116 }
 117
 118 static int64_t
 119 read_int64 (unsigned char *p)
 120 {
 121         uint64_t value = *p++;
 122         value |= (*p++) << 8;
 123         value |= (*p++) << 16;
 124         value |= (uint64_t)(*p++) << 24;
 125         value |= (uint64_t)(*p++) << 32;
 126         value |= (uint64_t)(*p++) << 40;
 127         value |= (uint64_t)(*p++) << 48;
 128         value |= (uint64_t)(*p++) << 54;
 129         return value;
 130 }
 131
 132 static char*
 133 pstrdup (const char *s)
 134 {
 135         int len = strlen (s) + 1;
 136         char *p = (char *)malloc (len);
 137         memcpy (p, s, len);
 138         return p;
 139 }
 140
 141 typedef struct _CounterValue CounterValue;
 142 struct _CounterValue {
 143         uint64_t timestamp;
 144         unsigned char *buffer;
 145         CounterValue *next;
 146 };
 147
 148 typedef struct _Counter Counter;
 149 struct _Counter {
 150         int index;
 151         const char *section;
 152         const char *name;
 153         int type;
 154         int unit;
 155         int variance;
 156         CounterValue *values;
 157         CounterValue *values_last;
 158 };
 159
 160 typedef struct _CounterList CounterList;
 161 struct _CounterList {
 162         Counter *counter;
 163         CounterList *next;
 164 };
 165
 166 typedef struct _CounterSection CounterSection;
 167 struct _CounterSection {
 168         const char *value;
 169         CounterList *counters;
 170         CounterList *counters_last;
 171         CounterSection *next;
 172 };
 173
 174 typedef struct _CounterTimestamp CounterTimestamp;
 175 struct _CounterTimestamp {
 176         uint64_t value;
 177         CounterSection *sections;
 178         CounterSection *sections_last;
 179         CounterTimestamp *next;
 180 };
 181
 182 static CounterList *counters = NULL;
 183 static CounterSection *counters_sections = NULL;
 184 static CounterTimestamp *counters_timestamps = NULL;
 185
 186 enum {
 187         COUNTERS_SORT_TIME,
 188         COUNTERS_SORT_CATEGORY
 189 };
 190
 191 static int counters_sort_mode = COUNTERS_SORT_TIME;
 192
 193 static void
 194 add_counter_to_section (Counter *counter)
 195 {
 196         CounterSection *csection, *s;
 197         CounterList *clist;
 198
 199         clist = (CounterList *)calloc (1, sizeof (CounterList));
 200         clist->counter = counter;
 201
 202         for (csection = counters_sections; csection; csection = csection->next) {
 203                 if (strcmp (csection->value, counter->section) == 0) {
 204                         /* If section exist */
 205                         if (!csection->counters)
 206                                 csection->counters = clist;
 207                         else
 208                                 csection->counters_last->next = clist;
 209                         csection->counters_last = clist;
 210                         return;
 211                 }
 212         }
 213
 214         /* If section does not exist */
 215         csection = (CounterSection *)calloc (1, sizeof (CounterSection));
 216         csection->value = counter->section;
 217         csection->counters = clist;
 218         csection->counters_last = clist;
 219
 220         if (!counters_sections) {
 221                 counters_sections = csection;
 222         } else {
 223                 s = counters_sections;
 224                 while (s->next)
 225                         s = s->next;
 226                 s->next = csection;
 227         }
 228 }
 229
 230 static void
 231 add_counter (const char *section, const char *name, int type, int unit, int variance, int index)
 232 {
 233         CounterList *list, *l;
 234         Counter *counter;
 235
 236         for (list = counters; list; list = list->next)
 237                 if (list->counter->index == index)
 238                         return;
 239
 240         counter = (Counter *)calloc (1, sizeof (Counter));
 241         counter->section = section;
 242         counter->name = name;
 243         counter->type = type;
 244         counter->unit = unit;
 245         counter->variance = variance;
 246         counter->index = index;
 247
 248         list = (CounterList *)calloc (1, sizeof (CounterList));
 249         list->counter = counter;
 250
 251         if (!counters) {
 252                 counters = list;
 253         } else {
 254                 l = counters;
 255                 while (l->next)
 256                         l = l->next;
 257                 l->next = list;
 258         }
 259
 260         if (counters_sort_mode == COUNTERS_SORT_CATEGORY || !verbose)
 261                 add_counter_to_section (counter);
 262 }
 263
 264 static void
 265 add_counter_to_timestamp (uint64_t timestamp, Counter *counter)
 266 {
 267         CounterTimestamp *ctimestamp, *t;
 268         CounterSection *csection;
 269         CounterList *clist;
 270
 271         clist = (CounterList *)calloc (1, sizeof (CounterList));
 272         clist->counter = counter;
 273
 274         for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
 275                 if (ctimestamp->value == timestamp) {
 276                         for (csection = ctimestamp->sections; csection; csection = csection->next) {
 277                                 if (strcmp (csection->value, counter->section) == 0) {
 278                                         /* if timestamp exist and section exist */
 279                                         if (!csection->counters)
 280                                                 csection->counters = clist;
 281                                         else
 282                                                 csection->counters_last->next = clist;
 283                                         csection->counters_last = clist;
 284                                         return;
 285                                 }
 286                         }
 287
 288                         /* if timestamp exist and section does not exist */
 289                         csection = (CounterSection *)calloc (1, sizeof (CounterSection));
 290                         csection->value = counter->section;
 291                         csection->counters = clist;
 292                         csection->counters_last = clist;
 293
 294                         if (!ctimestamp->sections)
 295                                 ctimestamp->sections = csection;
 296                         else
 297                                 ctimestamp->sections_last->next = csection;
 298                         ctimestamp->sections_last = csection;
 299                         return;
 300                 }
 301         }
 302
 303         /* If timestamp do not exist and section does not exist */
 304         csection = (CounterSection *)calloc (1, sizeof (CounterSection));
 305         csection->value = counter->section;
 306         csection->counters = clist;
 307         csection->counters_last = clist;
 308
 309         ctimestamp = (CounterTimestamp *)calloc (1, sizeof (CounterTimestamp));
 310         ctimestamp->value = timestamp;
 311         ctimestamp->sections = csection;
 312         ctimestamp->sections_last = csection;
 313
 314         if (!counters_timestamps) {
 315                 counters_timestamps = ctimestamp;
 316         } else {
 317                 t = counters_timestamps;
 318                 while (t->next)
 319                         t = t->next;
 320                 t->next = ctimestamp;
 321         }
 322 }
 323
 324 static void
 325 add_counter_value (int index, CounterValue *value)
 326 {
 327         CounterList *list;
 328
 329         for (list = counters; list; list = list->next) {
 330                 if (list->counter->index == index) {
 331                         if (!list->counter->values)
 332                                 list->counter->values = value;
 333                         else
 334                                 list->counter->values_last->next = value;
 335                         list->counter->values_last = value;
 336
 337                         if (counters_sort_mode == COUNTERS_SORT_TIME)
 338                                 add_counter_to_timestamp (value->timestamp, list->counter);
 339
 340                         return;
 341                 }
 342         }
 343 }
 344
 345 static const char*
 346 section_name (int section)
 347 {
 348         switch (section) {
 349         case MONO_COUNTER_JIT: return "Mono JIT";
 350         case MONO_COUNTER_GC: return "Mono GC";
 351         case MONO_COUNTER_METADATA: return "Mono Metadata";
 352         case MONO_COUNTER_GENERICS: return "Mono Generics";
 353         case MONO_COUNTER_SECURITY: return "Mono Security";
 354         case MONO_COUNTER_RUNTIME: return "Mono Runtime";
 355         case MONO_COUNTER_SYSTEM: return "Mono System";
 356         default: return "<unknown>";
 357         }
 358 }
 359
 360 static const char*
 361 type_name (int type)
 362 {
 363         switch (type) {
 364         case MONO_COUNTER_INT: return "Int";
 365         case MONO_COUNTER_UINT: return "UInt";
 366         case MONO_COUNTER_WORD: return "Word";
 367         case MONO_COUNTER_LONG: return "Long";
 368         case MONO_COUNTER_ULONG: return "ULong";
 369         case MONO_COUNTER_DOUBLE: return "Double";
 370         case MONO_COUNTER_STRING: return "String";
 371         case MONO_COUNTER_TIME_INTERVAL: return "Time Interval";
 372         default: return "<unknown>";
 373         }
 374 }
 375
 376 static const char*
 377 unit_name (int unit)
 378 {
 379         switch (unit) {
 380         case MONO_COUNTER_RAW: return "Raw";
 381         case MONO_COUNTER_BYTES: return "Bytes";
 382         case MONO_COUNTER_TIME: return "Time";
 383         case MONO_COUNTER_COUNT: return "Count";
 384         case MONO_COUNTER_PERCENTAGE: return "Percentage";
 385         default: return "<unknown>";
 386         }
 387 }
 388
 389 static const char*
 390 variance_name (int variance)
 391 {
 392         switch (variance) {
 393         case MONO_COUNTER_MONOTONIC: return "Monotonic";
 394         case MONO_COUNTER_CONSTANT: return "Constant";
 395         case MONO_COUNTER_VARIABLE: return "Variable";
 396         default: return "<unknown>";
 397         }
 398 }
 399
 400 static void
 401 dump_counters_value (Counter *counter, const char *key_format, const char *key, void *value)
 402 {
 403         char format[32];
 404
 405         if (value == NULL) {
 406                 snprintf (format, sizeof (format), "%s : %%s\n", key_format);
 407                 fprintf (outfile, format, key, "<null>");
 408         } else {
 409                 switch (counter->type) {
 410                 case MONO_COUNTER_INT:
 411 #if SIZEOF_VOID_P == 4
 412                 case MONO_COUNTER_WORD:
 413 #endif
 414                         snprintf (format, sizeof (format), "%s : %%d\n", key_format);
 415                         fprintf (outfile, format, key, *(int32_t*)value);
 416                         break;
 417                 case MONO_COUNTER_UINT:
 418                         snprintf (format, sizeof (format), "%s : %%u\n", key_format);
 419                         fprintf (outfile, format, key, *(uint32_t*)value);
 420                         break;
 421                 case MONO_COUNTER_LONG:
 422 #if SIZEOF_VOID_P == 8
 423                 case MONO_COUNTER_WORD:
 424 #endif
 425                 case MONO_COUNTER_TIME_INTERVAL:
 426                         if (counter->type == MONO_COUNTER_LONG && counter->unit == MONO_COUNTER_TIME) {
 427                                 snprintf (format, sizeof (format), "%s : %%0.3fms\n", key_format);
 428                                 fprintf (outfile, format, key, (double)*(int64_t*)value / 10000.0);
 429                         } else if (counter->type == MONO_COUNTER_TIME_INTERVAL) {
 430                                 snprintf (format, sizeof (format), "%s : %%0.3fms\n", key_format);
 431                                 fprintf (outfile, format, key, (double)*(int64_t*)value / 1000.0);
 432                         } else {
 433                                 snprintf (format, sizeof (format), "%s : %%u\n", key_format);
 434                                 fprintf (outfile, format, key, *(int64_t*)value);
 435                         }
 436                         break;
 437                 case MONO_COUNTER_ULONG:
 438                         snprintf (format, sizeof (format), "%s : %%llu\n", key_format);
 439                         fprintf (outfile, format, key, *(uint64_t*)value);
 440                         break;
 441                 case MONO_COUNTER_DOUBLE:
 442                         snprintf (format, sizeof (format), "%s : %%f\n", key_format);
 443                         fprintf (outfile, format, key, *(double*)value);
 444                         break;
 445                 case MONO_COUNTER_STRING:
 446                         snprintf (format, sizeof (format), "%s : %%s\n", key_format);
 447                         fprintf (outfile, format, key, *(char*)value);
 448                         break;
 449                 }
 450         }
 451 }
 452
 453 static void
 454 dump_counters (void)
 455 {
 456         Counter *counter;
 457         CounterValue *cvalue;
 458         CounterTimestamp *ctimestamp;
 459         CounterSection *csection;
 460         CounterList *clist;
 461         char strtimestamp[17];
 462         int i, section_printed;
 463
 464         fprintf (outfile, "\nCounters:\n");
 465
 466         if (!verbose) {
 467                 char counters_to_print[][64] = {
 468                         "Methods from AOT",
 469                         "Methods JITted using mono JIT",
 470                         "Methods JITted using LLVM",
 471                         "Total time spent JITting (sec)",
 472                         "User Time",
 473                         "System Time",
 474                         "Total Time",
 475                         "Working Set",
 476                         "Private Bytes",
 477                         "Virtual Bytes",
 478                         "Page Faults",
 479                         "CPU Load Average - 1min",
 480                         "CPU Load Average - 5min",
 481                         "CPU Load Average - 15min",
 482                         ""
 483                 };
 484
 485                 for (csection = counters_sections; csection; csection = csection->next) {
 486                         section_printed = 0;
 487
 488                         for (clist = csection->counters; clist; clist = clist->next) {
 489                                 counter = clist->counter;
 490                                 if (!counter->values_last)
 491                                         continue;
 492
 493                                 for (i = 0; counters_to_print [i][0] != 0; i++) {
 494                                         if (strcmp (counters_to_print [i], counter->name) == 0) {
 495                                                 if (!section_printed) {
 496                                                         fprintf (outfile, "\t%s:\n", csection->value);
 497                                                         section_printed = 1;
 498                                                 }
 499
 500                                                 dump_counters_value (counter, "\t\t%-30s", counter->name, counter->values_last->buffer);
 501                                                 break;
 502                                         }
 503                                 }
 504                         }
 505                 }
 506         } else if (counters_sort_mode == COUNTERS_SORT_TIME) {
 507                 for (ctimestamp = counters_timestamps; ctimestamp; ctimestamp = ctimestamp->next) {
 508                         fprintf (outfile, "\t%llu:%02llu:%02llu:%02llu.%03llu:\n",
 509                                 (unsigned long long) (ctimestamp->value / 1000 / 60 / 60 / 24 % 1000),
 510                                 (unsigned long long) (ctimestamp->value / 1000 / 60 / 60 % 24),
 511                                 (unsigned long long) (ctimestamp->value / 1000 / 60 % 60),
 512                                 (unsigned long long) (ctimestamp->value / 1000 % 60),
 513                                 (unsigned long long) (ctimestamp->value % 1000));
 514
 515                         for (csection = ctimestamp->sections; csection; csection = csection->next) {
 516                                 fprintf (outfile, "\t\t%s:\n", csection->value);
 517
 518                                 for (clist = csection->counters; clist; clist = clist->next) {
 519                                         counter = clist->counter;
 520                                         for (cvalue = counter->values; cvalue; cvalue = cvalue->next) {
 521                                                 if (cvalue->timestamp != ctimestamp->value)
 522                                                         continue;
 523
 524                                                 dump_counters_value (counter, "\t\t\t%-30s", counter->name, cvalue->buffer);
 525                                         }
 526                                 }
 527                         }
 528                 }
 529         } else if (counters_sort_mode == COUNTERS_SORT_CATEGORY) {
 530                 for (csection = counters_sections; csection; csection = csection->next) {
 531                         fprintf (outfile, "\t%s:\n", csection->value);
 532
 533                         for (clist = csection->counters; clist; clist = clist->next) {
 534                                 counter = clist->counter;
 535                                 fprintf (outfile, "\t\t%s: [type: %s, unit: %s, variance: %s]\n",
 536                                         counter->name, type_name (counter->type), unit_name (counter->unit), variance_name (counter->variance));
 537
 538                                 for (cvalue = counter->values; cvalue; cvalue = cvalue->next) {
 539                                         snprintf (strtimestamp, sizeof (strtimestamp), "%llu:%02llu:%02llu:%02llu.%03llu",
 540                                                 (unsigned long long) (cvalue->timestamp / 1000 / 60 / 60 / 24 % 1000),
 541                                                 (unsigned long long) (cvalue->timestamp / 1000 / 60 / 60 % 24),
 542                                                 (unsigned long long) (cvalue->timestamp / 1000 / 60 % 60),
 543                                                 (unsigned long long) (cvalue->timestamp / 1000 % 60),
 544                                                 (unsigned long long) (cvalue->timestamp % 1000));
 545
 546                                         dump_counters_value (counter, "\t\t\t%s", strtimestamp, cvalue->buffer);
 547                                 }
 548                         }
 549                 }
 550         }
 551 }
 552
 553 static int num_images;
 554 typedef struct _ImageDesc ImageDesc;
 555 struct _ImageDesc {
 556         ImageDesc *next;
 557         intptr_t image;
 558         char *filename;
 559 };
 560
 561 static ImageDesc* image_hash [SMALL_HASH_SIZE] = {0};
 562
 563 static void
 564 add_image (intptr_t image, char *name)
 565 {
 566         int slot = ((image >> 2) & 0xffff) % SMALL_HASH_SIZE;
 567         ImageDesc *cd = (ImageDesc *)malloc (sizeof (ImageDesc));
 568         cd->image = image;
 569         cd->filename = pstrdup (name);
 570         cd->next = image_hash [slot];
 571         image_hash [slot] = cd;
 572         num_images++;
 573 }
 574
 575 static int num_assemblies;
 576
 577 typedef struct _AssemblyDesc AssemblyDesc;
 578 struct _AssemblyDesc {
 579         AssemblyDesc *next;
 580         intptr_t assembly;
 581         char *asmname;
 582 };
 583
 584 static AssemblyDesc* assembly_hash [SMALL_HASH_SIZE] = {0};
 585
 586 static void
 587 add_assembly (intptr_t assembly, char *name)
 588 {
 589         int slot = ((assembly >> 2) & 0xffff) % SMALL_HASH_SIZE;
 590         AssemblyDesc *cd = (AssemblyDesc *)malloc (sizeof (AssemblyDesc));
 591         cd->assembly = assembly;
 592         cd->asmname = pstrdup (name);
 593         cd->next = assembly_hash [slot];
 594         assembly_hash [slot] = cd;
 595         num_assemblies++;
 596 }
 597
 598 typedef struct _BackTrace BackTrace;
 599 typedef struct {
 600         uint64_t count;
 601         BackTrace *bt;
 602 } CallContext;
 603
 604 typedef struct {
 605         int count;
 606         int size;
 607         CallContext *traces;
 608 } TraceDesc;
 609
 610 typedef struct _ClassDesc ClassDesc;
 611 struct _ClassDesc {
 612         ClassDesc *next;
 613         intptr_t klass;
 614         char *name;
 615         intptr_t allocs;
 616         uint64_t alloc_size;
 617         TraceDesc traces;
 618 };
 619
 620 static ClassDesc* class_hash [HASH_SIZE] = {0};
 621 static int num_classes = 0;
 622
 623 static ClassDesc*
 624 add_class (intptr_t klass, const char *name)
 625 {
 626         int slot = ((klass >> 2) & 0xffff) % HASH_SIZE;
 627         ClassDesc *cd;
 628         cd = class_hash [slot];
 629         while (cd && cd->klass != klass)
 630                 cd = cd->next;
 631         /* we resolved an unknown class (unless we had the code unloaded) */
 632         if (cd) {
 633                 /*printf ("resolved unknown: %s\n", name);*/
 634                 free (cd->name);
 635                 cd->name = pstrdup (name);
 636                 return cd;
 637         }
 638         cd = (ClassDesc *)calloc (sizeof (ClassDesc), 1);
 639         cd->klass = klass;
 640         cd->name = pstrdup (name);
 641         cd->next = class_hash [slot];
 642         cd->allocs = 0;
 643         cd->alloc_size = 0;
 644         cd->traces.count = 0;
 645         cd->traces.size = 0;
 646         cd->traces.traces = NULL;
 647         class_hash [slot] = cd;
 648         num_classes++;
 649         return cd;
 650 }
 651
 652 static ClassDesc *
 653 lookup_class (intptr_t klass)
 654 {
 655         int slot = ((klass >> 2) & 0xffff) % HASH_SIZE;
 656         ClassDesc *cd = class_hash [slot];
 657         while (cd && cd->klass != klass)
 658                 cd = cd->next;
 659         if (!cd) {
 660                 char buf [128];
 661                 snprintf (buf, sizeof (buf), "unresolved class %p", (void*)klass);
 662                 return add_class (klass, buf);
 663         }
 664         return cd;
 665 }
 666
 667 typedef struct _MethodDesc MethodDesc;
 668 struct _MethodDesc {
 669         MethodDesc *next;
 670         intptr_t method;
 671         char *name;
 672         intptr_t code;
 673         int len;
 674         int recurse_count;
 675         int sample_hits;
 676         int ignore_jit; /* when this is set, we collect the metadata but don't count this method fot jit time and code size, when filtering events */
 677         uint64_t calls;
 678         uint64_t total_time;
 679         uint64_t callee_time;
 680         uint64_t self_time;
 681         TraceDesc traces;
 682 };
 683
 684 static MethodDesc* method_hash [HASH_SIZE] = {0};
 685 static int num_methods = 0;
 686
 687 static MethodDesc*
 688 add_method (intptr_t method, const char *name, intptr_t code, int len)
 689 {
 690         int slot = ((method >> 2) & 0xffff) % HASH_SIZE;
 691         MethodDesc *cd;
 692         cd = method_hash [slot];
 693         while (cd && cd->method != method)
 694                 cd = cd->next;
 695         /* we resolved an unknown method (unless we had the code unloaded) */
 696         if (cd) {
 697                 cd->code = code;
 698                 cd->len = len;
 699                 /*printf ("resolved unknown: %s\n", name);*/
 700                 free (cd->name);
 701                 cd->name = pstrdup (name);
 702                 return cd;
 703         }
 704         cd = (MethodDesc *)calloc (sizeof (MethodDesc), 1);
 705         cd->method = method;
 706         cd->name = pstrdup (name);
 707         cd->code = code;
 708         cd->len = len;
 709         cd->calls = 0;
 710         cd->total_time = 0;
 711         cd->traces.count = 0;
 712         cd->traces.size = 0;
 713         cd->traces.traces = NULL;
 714         cd->next = method_hash [slot];
 715         method_hash [slot] = cd;
 716         num_methods++;
 717         return cd;
 718 }
 719
 720 static MethodDesc *
 721 lookup_method (intptr_t method)
 722 {
 723         int slot = ((method >> 2) & 0xffff) % HASH_SIZE;
 724         MethodDesc *cd = method_hash [slot];
 725         while (cd && cd->method != method)
 726                 cd = cd->next;
 727         if (!cd) {
 728                 char buf [128];
 729                 snprintf (buf, sizeof (buf), "unknown method %p", (void*)method);
 730                 return add_method (method, buf, 0, 0);
 731         }
 732         return cd;
 733 }
 734
 735 static int num_stat_samples = 0;
 736 static int size_stat_samples = 0;
 737 uintptr_t *stat_samples = NULL;
 738 int *stat_sample_desc = NULL;
 739
 740 static void
 741 add_stat_sample (int type, uintptr_t ip) {
 742         if (num_stat_samples == size_stat_samples) {
 743                 size_stat_samples *= 2;
 744                 if (!size_stat_samples)
 745                 size_stat_samples = 32;
 746                 stat_samples = (uintptr_t *)realloc (stat_samples, size_stat_samples * sizeof (uintptr_t));
 747                 stat_sample_desc = (int *)realloc (stat_sample_desc, size_stat_samples * sizeof (int));
 748         }
 749         stat_samples [num_stat_samples] = ip;
 750         stat_sample_desc [num_stat_samples++] = type;
 751 }
 752
 753 static MethodDesc*
 754 lookup_method_by_ip (uintptr_t ip)
 755 {
 756         int i;
 757         MethodDesc* m;
 758         /* dumb */
 759         for (i = 0; i < HASH_SIZE; ++i) {
 760                 m = method_hash [i];
 761                 while (m) {
 762                         //printf ("checking %p against %p-%p\n", (void*)ip, (void*)(m->code), (void*)(m->code + m->len));
 763                         if (ip >= (uintptr_t)m->code && ip < (uintptr_t)m->code + m->len) {
 764                                 return m;
 765                         }
 766                         m = m->next;
 767                 }
 768         }
 769         return NULL;
 770 }
 771
 772 static int
 773 compare_method_samples (const void *a, const void *b)
 774 {
 775         MethodDesc *const *A = (MethodDesc *const *)a;
 776         MethodDesc *const *B = (MethodDesc *const *)b;
 777         if ((*A)->sample_hits == (*B)->sample_hits)
 778                 return 0;
 779         if ((*B)->sample_hits < (*A)->sample_hits)
 780                 return -1;
 781         return 1;
 782 }
 783
 784 typedef struct _UnmanagedSymbol UnmanagedSymbol;
 785 struct _UnmanagedSymbol {
 786         UnmanagedSymbol *parent;
 787         char *name;
 788         int is_binary;
 789         uintptr_t addr;
 790         uintptr_t size;
 791         uintptr_t sample_hits;
 792 };
 793
 794 static UnmanagedSymbol **usymbols = NULL;
 795 static int usymbols_size = 0;
 796 static int usymbols_num = 0;
 797
 798 static int
 799 compare_usymbol_addr (const void *a, const void *b)
 800 {
 801         UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
 802         UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
 803         if ((*B)->addr == (*A)->addr)
 804                 return 0;
 805         if ((*B)->addr > (*A)->addr)
 806                 return -1;
 807         return 1;
 808 }
 809
 810 static int
 811 compare_usymbol_samples (const void *a, const void *b)
 812 {
 813         UnmanagedSymbol *const *A = (UnmanagedSymbol *const *)a;
 814         UnmanagedSymbol *const *B = (UnmanagedSymbol *const *)b;
 815         if ((*B)->sample_hits == (*A)->sample_hits)
 816                 return 0;
 817         if ((*B)->sample_hits < (*A)->sample_hits)
 818                 return -1;
 819         return 1;
 820 }
 821
 822 static void
 823 add_unmanaged_symbol (uintptr_t addr, char *name, uintptr_t size)
 824 {
 825         UnmanagedSymbol *sym;
 826         if (usymbols_num == usymbols_size) {
 827                 int new_size = usymbols_size * 2;
 828                 if (!new_size)
 829                         new_size = 16;
 830                 usymbols = (UnmanagedSymbol **)realloc (usymbols, sizeof (void*) * new_size);
 831                 usymbols_size = new_size;
 832         }
 833         sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
 834         sym->addr = addr;
 835         sym->name = name;
 836         sym->size = size;
 837         usymbols [usymbols_num++] = sym;
 838 }
 839
 840 /* only valid after the symbols are sorted */
 841 static UnmanagedSymbol*
 842 lookup_unmanaged_symbol (uintptr_t addr)
 843 {
 844         int r = usymbols_num - 1;
 845         int l = 0;
 846         UnmanagedSymbol *sym;
 847         int last_best = -1;
 848         while (r >= l) {
 849                 int m = (l + r) / 2;
 850                 sym = usymbols [m];
 851                 if (addr == sym->addr)
 852                         return sym;
 853                 if (addr < sym->addr) {
 854                         r = m - 1;
 855                 } else if (addr > sym->addr) {
 856                         l = m + 1;
 857                         last_best = m;
 858                 }
 859         }
 860         if (last_best >= 0 && (addr - usymbols [last_best]->addr) < 4096)
 861                 return usymbols [last_best];
 862         return NULL;
 863 }
 864
 865 /* we use the same structure for binaries */
 866 static UnmanagedSymbol **ubinaries = NULL;
 867 static int ubinaries_size = 0;
 868 static int ubinaries_num = 0;
 869
 870 static void
 871 add_unmanaged_binary (uintptr_t addr, char *name, uintptr_t size)
 872 {
 873         UnmanagedSymbol *sym;
 874         if (ubinaries_num == ubinaries_size) {
 875                 int new_size = ubinaries_size * 2;
 876                 if (!new_size)
 877                         new_size = 16;
 878                 ubinaries = (UnmanagedSymbol **)realloc (ubinaries, sizeof (void*) * new_size);
 879                 ubinaries_size = new_size;
 880         }
 881         sym = (UnmanagedSymbol *)calloc (sizeof (UnmanagedSymbol), 1);
 882         sym->addr = addr;
 883         sym->name = name;
 884         sym->size = size;
 885         sym->is_binary = 1;
 886         ubinaries [ubinaries_num++] = sym;
 887 }
 888
 889 static UnmanagedSymbol*
 890 lookup_unmanaged_binary (uintptr_t addr)
 891 {
 892         int i;
 893         for (i = 0; i < ubinaries_num; ++i) {
 894                 UnmanagedSymbol *ubin = ubinaries [i];
 895                 if (addr >= ubin->addr && addr < ubin->addr + ubin->size) {
 896                         return ubin;
 897                 }
 898         }
 899         return NULL;
 900 }
 901
 902 static const char*
 903 sample_type_name (int type)
 904 {
 905         switch (type) {
 906         case SAMPLE_CYCLES: return "cycles";
 907         case SAMPLE_INSTRUCTIONS: return "instructions retired";
 908         case SAMPLE_CACHE_MISSES: return "cache misses";
 909         case SAMPLE_CACHE_REFS: return "cache references";
 910         case SAMPLE_BRANCHES: return "executed branches";
 911         case SAMPLE_BRANCH_MISSES: return "unpredicted branches";
 912         }
 913         return "unknown";
 914 }
 915
 916 static void
 917 set_usym_parent (UnmanagedSymbol** cachedus, int count)
 918 {
 919         int i;
 920         for (i = 0; i < count; ++i) {
 921                 UnmanagedSymbol *ubin = lookup_unmanaged_binary (cachedus [i]->addr);
 922                 if (ubin == cachedus [i])
 923                         continue;
 924                 cachedus [i]->parent = ubin;
 925         }
 926 }
 927
 928 static void
 929 print_usym (UnmanagedSymbol* um)
 930 {
 931         if (um->parent)
 932                 fprintf (outfile, "\t%6zd %6.2f %-36s in %s\n", um->sample_hits, um->sample_hits*100.0/num_stat_samples, um->name, um->parent->name);
 933         else
 934                 fprintf (outfile, "\t%6zd %6.2f %s\n", um->sample_hits, um->sample_hits*100.0/num_stat_samples, um->name);
 935 }
 936
 937 static int
 938 sym_percent (uintptr_t sample_hits)
 939 {
 940         double pc;
 941         if (verbose)
 942                 return 1;
 943         pc = sample_hits*100.0/num_stat_samples;
 944         return pc >= 0.1;
 945 }
 946
 947 static void
 948 dump_samples (void)
 949 {
 950         int i, u;
 951         int count = 0, msize = 0;
 952         int unmanaged_hits = 0;
 953         int unresolved_hits = 0;
 954         MethodDesc** cachedm = NULL;
 955         int ucount = 0, usize = 0;
 956         UnmanagedSymbol** cachedus = NULL;
 957         if (!num_stat_samples)
 958                 return;
 959         qsort (usymbols, usymbols_num, sizeof (UnmanagedSymbol*), compare_usymbol_addr);
 960         for (i = 0; i < num_stat_samples; ++i) {
 961                 MethodDesc *m = lookup_method_by_ip (stat_samples [i]);
 962                 if (m) {
 963                         if (!m->sample_hits) {
 964                                 if (count == msize) {
 965                                         msize *= 2;
 966                                         if (!msize)
 967                                                 msize = 4;
 968                                         cachedm = (MethodDesc **)realloc (cachedm, sizeof (void*) * msize);
 969                                 }
 970                                 cachedm [count++] = m;
 971                         }
 972                         m->sample_hits++;
 973                 } else {
 974                         UnmanagedSymbol *usym = lookup_unmanaged_symbol (stat_samples [i]);
 975                         if (!usym) {
 976                                 unresolved_hits++;
 977                                 //printf ("unmanaged hit at %p\n", (void*)stat_samples [i]);
 978                                 usym = lookup_unmanaged_binary (stat_samples [i]);
 979                         }
 980                         if (usym) {
 981                                 if (!usym->sample_hits) {
 982                                         if (ucount == usize) {
 983                                                 usize *= 2;
 984                                                 if (!usize)
 985                                                         usize = 4;
 986                                                 cachedus = (UnmanagedSymbol **)realloc (cachedus, sizeof (void*) * usize);
 987                                         }
 988                                         cachedus [ucount++] = usym;
 989                                 }
 990                                 usym->sample_hits++;
 991                         }
 992                         unmanaged_hits++;
 993                 }
 994         }
 995         qsort (cachedm, count, sizeof (MethodDesc*), compare_method_samples);
 996         qsort (cachedus, ucount, sizeof (UnmanagedSymbol*), compare_usymbol_samples);
 997         set_usym_parent (cachedus, ucount);
 998         fprintf (outfile, "\nStatistical samples summary\n");
 999         fprintf (outfile, "\tSample type: %s\n", sample_type_name (stat_sample_desc [0]));
1000         fprintf (outfile, "\tUnmanaged hits:  %6d (%4.1f%%)\n", unmanaged_hits, (100.0*unmanaged_hits)/num_stat_samples);
1001         fprintf (outfile, "\tManaged hits:    %6d (%4.1f%%)\n", num_stat_samples - unmanaged_hits, (100.0*(num_stat_samples-unmanaged_hits))/num_stat_samples);
1002         fprintf (outfile, "\tUnresolved hits: %6d (%4.1f%%)\n", unresolved_hits, (100.0*unresolved_hits)/num_stat_samples);
1003         fprintf (outfile, "\t%6s %6s %s\n", "Hits", "%", "Method name");
1004         i = 0;
1005         u = 0;
1006         while (i < count || u < ucount) {
1007                 if (i < count) {
1008                         MethodDesc *m = cachedm [i];
1009                         if (u < ucount) {
1010                                 UnmanagedSymbol *um = cachedus [u];
1011                                 if (um->sample_hits > m->sample_hits) {
1012                                         if (!sym_percent (um->sample_hits))
1013                                                 break;
1014                                         print_usym (um);
1015                                         u++;
1016                                         continue;
1017                                 }
1018                         }
1019                         if (!sym_percent (m->sample_hits))
1020                                 break;
1021                         fprintf (outfile, "\t%6d %6.2f %s\n", m->sample_hits, m->sample_hits*100.0/num_stat_samples, m->name);
1022                         i++;
1023                         continue;
1024                 }
1025                 if (u < ucount) {
1026                         UnmanagedSymbol *um = cachedus [u];
1027                         if (!sym_percent (um->sample_hits))
1028                                 break;
1029                         print_usym (um);
1030                         u++;
1031                         continue;
1032                 }
1033         }
1034 }
1035
1036 typedef struct _HeapClassDesc HeapClassDesc;
1037 typedef struct {
1038         HeapClassDesc *klass;
1039         uint64_t count;
1040 } HeapClassRevRef;
1041
1042 struct _HeapClassDesc {
1043         ClassDesc *klass;
1044         int64_t count;
1045         int64_t total_size;
1046         HeapClassRevRef *rev_hash;
1047         int rev_hash_size;
1048         int rev_count;
1049         uintptr_t pinned_references;
1050         uintptr_t root_references;
1051 };
1052
1053 static int
1054 add_rev_class_hashed (HeapClassRevRef *rev_hash, uintptr_t size, HeapClassDesc *hklass, uint64_t value)
1055 {
1056         uintptr_t i;
1057         uintptr_t start_pos;
1058         start_pos = (hklass->klass->klass >> 2) % size;
1059         assert (start_pos < size);
1060         i = start_pos;
1061         do {
1062                 if (rev_hash [i].klass == hklass) {
1063                         rev_hash [i].count += value;
1064                         return 0;
1065                 } else if (!rev_hash [i].klass) {
1066                         rev_hash [i].klass = hklass;
1067                         rev_hash [i].count += value;
1068                         start_pos = 0;
1069                         for (i = 0; i < size; ++i)
1070                                 if (rev_hash [i].klass && rev_hash [i].klass->klass == hklass->klass)
1071                                         start_pos ++;
1072                         assert (start_pos == 1);
1073                         return 1;
1074                 }
1075                 /* wrap around */
1076                 if (++i == size)
1077                         i = 0;
1078         } while (i != start_pos);
1079         /* should not happen */
1080         printf ("failed revref store\n");
1081         return 0;
1082 }
1083
1084 static void
1085 add_heap_class_rev (HeapClassDesc *from, HeapClassDesc *to)
1086 {
1087         uintptr_t i;
1088         if (to->rev_count * 2 >= to->rev_hash_size) {
1089                 HeapClassRevRef *n;
1090                 uintptr_t old_size = to->rev_hash_size;
1091                 to->rev_hash_size *= 2;
1092                 if (to->rev_hash_size == 0)
1093                         to->rev_hash_size = 4;
1094                 n = (HeapClassRevRef *)calloc (sizeof (HeapClassRevRef) * to->rev_hash_size, 1);
1095                 for (i = 0; i < old_size; ++i) {
1096                         if (to->rev_hash [i].klass)
1097                                 add_rev_class_hashed (n, to->rev_hash_size, to->rev_hash [i].klass, to->rev_hash [i].count);
1098                 }
1099                 if (to->rev_hash)
1100                         free (to->rev_hash);
1101                 to->rev_hash = n;
1102         }
1103         to->rev_count += add_rev_class_hashed (to->rev_hash, to->rev_hash_size, from, 1);
1104 }
1105
1106 typedef struct {
1107         uintptr_t objaddr;
1108         HeapClassDesc *hklass;
1109         uintptr_t num_refs;
1110         uintptr_t refs [0];
1111 } HeapObjectDesc;
1112
1113 typedef struct _HeapShot HeapShot;
1114 struct _HeapShot {
1115         HeapShot *next;
1116         uint64_t timestamp;
1117         int class_count;
1118         int hash_size;
1119         HeapClassDesc **class_hash;
1120         HeapClassDesc **sorted;
1121         HeapObjectDesc **objects_hash;
1122         uintptr_t objects_count;
1123         uintptr_t objects_hash_size;
1124         uintptr_t num_roots;
1125         uintptr_t *roots;
1126         uintptr_t *roots_extra;
1127         int *roots_types;
1128 };
1129
1130 static HeapShot *heap_shots = NULL;
1131 static int num_heap_shots = 0;
1132
1133 static HeapShot*
1134 new_heap_shot (uint64_t timestamp)
1135 {
1136         HeapShot *hs = (HeapShot *)calloc (sizeof (HeapShot), 1);
1137         hs->hash_size = 4;
1138         hs->class_hash = (HeapClassDesc **)calloc (sizeof (void*), hs->hash_size);
1139         hs->timestamp = timestamp;
1140         num_heap_shots++;
1141         hs->next = heap_shots;
1142         heap_shots = hs;
1143         return hs;
1144 }
1145
1146 static HeapClassDesc*
1147 heap_class_lookup (HeapShot *hs, ClassDesc *klass)
1148 {
1149         int i;
1150         unsigned int start_pos;
1151         start_pos = ((uintptr_t)klass->klass >> 2) % hs->hash_size;
1152         i = start_pos;
1153         do {
1154                 HeapClassDesc* cd = hs->class_hash [i];
1155                 if (!cd)
1156                         return NULL;
1157                 if (cd->klass == klass)
1158                         return cd;
1159                 /* wrap around */
1160                 if (++i == hs->hash_size)
1161                         i = 0;
1162         } while (i != start_pos);
1163         return NULL;
1164 }
1165
1166 static int
1167 add_heap_hashed (HeapClassDesc **hash, HeapClassDesc **retv, uintptr_t hsize, ClassDesc *klass, uint64_t size, uint64_t count)
1168 {
1169         uintptr_t i;
1170         uintptr_t start_pos;
1171         start_pos = ((uintptr_t)klass->klass >> 2) % hsize;
1172         i = start_pos;
1173         do {
1174                 if (hash [i] && hash [i]->klass == klass) {
1175                         hash [i]->total_size += size;
1176                         hash [i]->count += count;
1177                         *retv = hash [i];
1178                         return 0;
1179                 } else if (!hash [i]) {
1180                         if (*retv) {
1181                                 hash [i] = *retv;
1182                                 return 1;
1183                         }
1184                         hash [i] = (HeapClassDesc *)calloc (sizeof (HeapClassDesc), 1);
1185                         hash [i]->klass = klass;
1186                         hash [i]->total_size += size;
1187                         hash [i]->count += count;
1188                         *retv = hash [i];
1189                         return 1;
1190                 }
1191                 /* wrap around */
1192                 if (++i == hsize)
1193                         i = 0;
1194         } while (i != start_pos);
1195         /* should not happen */
1196         printf ("failed heap class store\n");
1197         return 0;
1198 }
1199
1200 static HeapClassDesc*
1201 add_heap_shot_class (HeapShot *hs, ClassDesc *klass, uint64_t size)
1202 {
1203         HeapClassDesc *res;
1204         int i;
1205         if (hs->class_count * 2 >= hs->hash_size) {
1206                 HeapClassDesc **n;
1207                 int old_size = hs->hash_size;
1208                 hs->hash_size *= 2;
1209                 if (hs->hash_size == 0)
1210                         hs->hash_size = 4;
1211                 n = (HeapClassDesc **)calloc (sizeof (void*) * hs->hash_size, 1);
1212                 for (i = 0; i < old_size; ++i) {
1213                         res = hs->class_hash [i];
1214                         if (hs->class_hash [i])
1215                                 add_heap_hashed (n, &res, hs->hash_size, hs->class_hash [i]->klass, hs->class_hash [i]->total_size, hs->class_hash [i]->count);
1216                 }
1217                 if (hs->class_hash)
1218                         free (hs->class_hash);
1219                 hs->class_hash = n;
1220         }
1221         res = NULL;
1222         hs->class_count += add_heap_hashed (hs->class_hash, &res, hs->hash_size, klass, size, 1);
1223         //if (res->count == 1)
1224         //      printf ("added heap class: %s\n", res->klass->name);
1225         return res;
1226 }
1227
1228 static HeapObjectDesc*
1229 alloc_heap_obj (uintptr_t objaddr, HeapClassDesc *hklass, uintptr_t num_refs)
1230 {
1231         HeapObjectDesc* ho = (HeapObjectDesc *)calloc (sizeof (HeapObjectDesc) + num_refs * sizeof (uintptr_t), 1);
1232         ho->objaddr = objaddr;
1233         ho->hklass = hklass;
1234         ho->num_refs = num_refs;
1235         return ho;
1236 }
1237
1238 static uintptr_t
1239 heap_shot_find_obj_slot (HeapShot *hs, uintptr_t objaddr)
1240 {
1241         uintptr_t i;
1242         uintptr_t start_pos;
1243         HeapObjectDesc **hash = hs->objects_hash;
1244         start_pos = ((uintptr_t)objaddr >> 3) % hs->objects_hash_size;
1245         i = start_pos;
1246         do {
1247                 if (hash [i] && hash [i]->objaddr == objaddr) {
1248                         return i;
1249                 } else if (!hash [i]) {
1250                         break; /* fail */
1251                 }
1252                 /* wrap around */
1253                 if (++i == hs->objects_hash_size)
1254                         i = 0;
1255         } while (i != start_pos);
1256         /* should not happen */
1257         //printf ("failed heap obj slot\n");
1258         return -1;
1259 }
1260
1261 static HeapObjectDesc*
1262 heap_shot_obj_add_refs (HeapShot *hs, uintptr_t objaddr, uintptr_t num, uintptr_t *ref_offset)
1263 {
1264         HeapObjectDesc **hash = hs->objects_hash;
1265         uintptr_t i = heap_shot_find_obj_slot (hs, objaddr);
1266         if (i >= 0) {
1267                 HeapObjectDesc* ho = alloc_heap_obj (objaddr, hash [i]->hklass, hash [i]->num_refs + num);
1268                 *ref_offset = hash [i]->num_refs;
1269                 memcpy (ho->refs, hash [i]->refs, hash [i]->num_refs * sizeof (uintptr_t));
1270                 free (hash [i]);
1271                 hash [i] = ho;
1272                 return ho;
1273         }
1274         /* should not happen */
1275         printf ("failed heap obj update\n");
1276         return NULL;
1277
1278 }
1279
1280 static uintptr_t
1281 add_heap_hashed_obj (HeapObjectDesc **hash, uintptr_t hsize, HeapObjectDesc *obj)
1282 {
1283         uintptr_t i;
1284         uintptr_t start_pos;
1285         start_pos = ((uintptr_t)obj->objaddr >> 3) % hsize;
1286         i = start_pos;
1287         do {
1288                 if (hash [i] && hash [i]->objaddr == obj->objaddr) {
1289                         printf ("duplicate object!\n");
1290                         return 0;
1291                 } else if (!hash [i]) {
1292                         hash [i] = obj;
1293                         return 1;
1294                 }
1295                 /* wrap around */
1296                 if (++i == hsize)
1297                         i = 0;
1298         } while (i != start_pos);
1299         /* should not happen */
1300         printf ("failed heap obj store\n");
1301         return 0;
1302 }
1303
1304 static void
1305 add_heap_shot_obj (HeapShot *hs, HeapObjectDesc *obj)
1306 {
1307         uintptr_t i;
1308         if (hs->objects_count * 2 >= hs->objects_hash_size) {
1309                 HeapObjectDesc **n;
1310                 uintptr_t old_size = hs->objects_hash_size;
1311                 hs->objects_hash_size *= 2;
1312                 if (hs->objects_hash_size == 0)
1313                         hs->objects_hash_size = 4;
1314                 n = (HeapObjectDesc **)calloc (sizeof (void*) * hs->objects_hash_size, 1);
1315                 for (i = 0; i < old_size; ++i) {
1316                         if (hs->objects_hash [i])
1317                                 add_heap_hashed_obj (n, hs->objects_hash_size, hs->objects_hash [i]);
1318                 }
1319                 if (hs->objects_hash)
1320                         free (hs->objects_hash);
1321                 hs->objects_hash = n;
1322         }
1323         hs->objects_count += add_heap_hashed_obj (hs->objects_hash, hs->objects_hash_size, obj);
1324 }
1325
1326 static void
1327 heap_shot_resolve_reverse_refs (HeapShot *hs)
1328 {
1329         uintptr_t i;
1330         for (i = 0; i < hs->objects_hash_size; ++i) {
1331                 uintptr_t r;
1332                 HeapObjectDesc *ho = hs->objects_hash [i];
1333                 if (!ho)
1334                         continue;
1335                 for (r = 0; r < ho->num_refs; ++r) {
1336                         uintptr_t oi = heap_shot_find_obj_slot (hs, ho->refs [r]);
1337                         add_heap_class_rev (ho->hklass, hs->objects_hash [oi]->hklass);
1338                 }
1339         }
1340 }
1341
1342 #define MARK_GRAY 1
1343 #define MARK_BLACK 2
1344
1345 static void
1346 heap_shot_mark_objects (HeapShot *hs)
1347 {
1348         uintptr_t i, oi, r;
1349         unsigned char *marks;
1350         HeapObjectDesc *obj, *ref;
1351         int marked_some;
1352         uintptr_t num_marked = 0, num_unmarked;
1353         for (i = 0; i < hs->num_roots; ++i) {
1354                 HeapClassDesc *cd;
1355                 oi = heap_shot_find_obj_slot (hs, hs->roots [i]);
1356                 if (oi == -1) {
1357                         continue;
1358                 }
1359                 obj = hs->objects_hash [oi];
1360                 cd = obj->hklass;
1361                 if (hs->roots_types [i] & MONO_PROFILE_GC_ROOT_PINNING)
1362                         cd->pinned_references++;
1363                 cd->root_references++;
1364         }
1365         if (!debug)
1366                 return;
1367         /* consistency checks: it seems not all the objects are walked in the heap in some cases */
1368         marks = (unsigned char *)calloc (hs->objects_hash_size, 1);
1369         if (!marks)
1370                 return;
1371         for (i = 0; i < hs->num_roots; ++i) {
1372                 oi = heap_shot_find_obj_slot (hs, hs->roots [i]);
1373                 if (oi == -1) {
1374                         fprintf (outfile, "root type 0x%x for obj %p (%s) not found in heap\n", hs->roots_types [i], (void*)hs->roots [i], lookup_class (hs->roots_extra [i])->name);
1375                         continue;
1376                 }
1377                 obj = hs->objects_hash [oi];
1378                 if (!marks [oi]) {
1379                         marks [oi] = obj->num_refs? MARK_GRAY: MARK_BLACK;
1380                         num_marked++;
1381                 }
1382         }
1383         marked_some = 1;
1384         while (marked_some) {
1385                 marked_some = 0;
1386                 for (i = 0; i < hs->objects_hash_size; ++i) {
1387                         if (marks [i] != MARK_GRAY)
1388                                 continue;
1389                         marks [i] = MARK_BLACK;
1390                         obj = hs->objects_hash [i];
1391                         for (r = 0; r < obj->num_refs; ++r) {
1392                                 oi = heap_shot_find_obj_slot (hs, obj->refs [r]);
1393                                 if (oi == -1) {
1394                                         fprintf (outfile, "referenced obj %p not found in heap\n", (void*)obj->refs [r]);
1395                                         continue;
1396                                 }
1397                                 ref = hs->objects_hash [oi];
1398                                 if (!marks [oi]) {
1399                                         marks [oi] = ref->num_refs? MARK_GRAY: MARK_BLACK;
1400                                 }
1401                         }
1402                         marked_some++;
1403                 }
1404         }
1405
1406         num_unmarked = 0;
1407         for (i = 0; i < hs->objects_hash_size; ++i) {
1408                 if (hs->objects_hash [i] && !marks [i]) {
1409                         num_unmarked++;
1410                         fprintf (outfile, "object %p (%s) unmarked\n", (void*)hs->objects_hash [i], hs->objects_hash [i]->hklass->klass->name);
1411                 }
1412         }
1413         fprintf (outfile, "Total unmarked: %zd/%zd\n", num_unmarked, hs->objects_count);
1414         free (marks);
1415 }
1416
1417 static void
1418 heap_shot_free_objects (HeapShot *hs)
1419 {
1420         uintptr_t i;
1421         for (i = 0; i < hs->objects_hash_size; ++i) {
1422                 HeapObjectDesc *ho = hs->objects_hash [i];
1423                 if (ho)
1424                         free (ho);
1425         }
1426         if (hs->objects_hash)
1427                 free (hs->objects_hash);
1428         hs->objects_hash = NULL;
1429         hs->objects_hash_size = 0;
1430         hs->objects_count = 0;
1431 }
1432
1433
1434 struct _BackTrace {
1435         BackTrace *next;
1436         unsigned int hash;
1437         int count;
1438         int id;
1439         MethodDesc *methods [1];
1440 };
1441
1442 static BackTrace *backtrace_hash [HASH_SIZE];
1443 static BackTrace **backtraces = NULL;
1444 static int num_backtraces = 0;
1445 static int next_backtrace = 0;
1446
1447 static int
1448 hash_backtrace (int count, MethodDesc **methods)
1449 {
1450         int hash = count;
1451         int i;
1452         for (i = 0; i < count; ++i) {
1453                 hash = (hash << 5) - hash + methods [i]->method;
1454         }
1455         return hash;
1456 }
1457
1458 static int
1459 compare_backtrace (BackTrace *bt, int count, MethodDesc **methods)
1460 {
1461         int i;
1462         if (bt->count != count)
1463                 return 0;
1464         for (i = 0; i < count; ++i)
1465                 if (methods [i] != bt->methods [i])
1466                         return 0;
1467         return 1;
1468 }
1469
1470 static BackTrace*
1471 add_backtrace (int count, MethodDesc **methods)
1472 {
1473         int hash = hash_backtrace (count, methods);
1474         int slot = (hash & 0xffff) % HASH_SIZE;
1475         BackTrace *bt = backtrace_hash [slot];
1476         while (bt) {
1477                 if (bt->hash == hash && compare_backtrace (bt, count, methods))
1478                         return bt;
1479                 bt = bt->next;
1480         }
1481         bt = (BackTrace *)malloc (sizeof (BackTrace) + ((count - 1) * sizeof (void*)));
1482         bt->next = backtrace_hash [slot];
1483         backtrace_hash [slot] = bt;
1484         if (next_backtrace == num_backtraces) {
1485                 num_backtraces *= 2;
1486                 if (!num_backtraces)
1487                         num_backtraces = 16;
1488                 backtraces = (BackTrace **)realloc (backtraces, sizeof (void*) * num_backtraces);
1489         }
1490         bt->id = next_backtrace++;
1491         backtraces [bt->id] = bt;
1492         bt->count = count;
1493         bt->hash = hash;
1494         for (slot = 0; slot < count; ++slot)
1495                 bt->methods [slot] = methods [slot];
1496
1497         return bt;
1498 }
1499
1500 typedef struct _MonitorDesc MonitorDesc;
1501 typedef struct _ThreadContext ThreadContext;
1502 typedef struct _DomainContext DomainContext;
1503 typedef struct _RemCtxContext RemCtxContext;
1504
1505 typedef struct {
1506         FILE *file;
1507 #if defined (HAVE_SYS_ZLIB)
1508         gzFile gzfile;
1509 #endif
1510         unsigned char *buf;
1511         int size;
1512         int data_version;
1513         int version_major;
1514         int version_minor;
1515         int timer_overhead;
1516         int pid;
1517         int port;
1518         uint64_t startup_time;
1519         ThreadContext *threads;
1520         ThreadContext *current_thread;
1521         DomainContext *domains;
1522         DomainContext *current_domain;
1523         RemCtxContext *remctxs;
1524         RemCtxContext *current_remctx;
1525 } ProfContext;
1526
1527 struct _ThreadContext {
1528         ThreadContext *next;
1529         intptr_t thread_id;
1530         char *name;
1531         /* emulated stack */
1532         MethodDesc **stack;
1533         uint64_t *time_stack;
1534         uint64_t *callee_time_stack;
1535         uint64_t last_time;
1536         uint64_t contention_start;
1537         MonitorDesc *monitor;
1538         int stack_size;
1539         int stack_id;
1540         HeapShot *current_heap_shot;
1541         uintptr_t num_roots;
1542         uintptr_t size_roots;
1543         uintptr_t *roots;
1544         uintptr_t *roots_extra;
1545         int *roots_types;
1546         uint64_t gc_start_times [3];
1547 };
1548
1549 struct _DomainContext {
1550         DomainContext *next;
1551         intptr_t domain_id;
1552         const char *friendly_name;
1553 };
1554
1555 struct _RemCtxContext {
1556         RemCtxContext *next;
1557         intptr_t remctx_id;
1558         intptr_t domain_id;
1559 };
1560
1561 static void
1562 ensure_buffer (ProfContext *ctx, int size)
1563 {
1564         if (ctx->size < size) {
1565                 ctx->buf = (unsigned char *)realloc (ctx->buf, size);
1566                 ctx->size = size;
1567         }
1568 }
1569
1570 static int
1571 load_data (ProfContext *ctx, int size)
1572 {
1573         ensure_buffer (ctx, size);
1574 #if defined (HAVE_SYS_ZLIB)
1575         if (ctx->gzfile) {
1576                 int r = gzread (ctx->gzfile, ctx->buf, size);
1577                 if (r == 0)
1578                         return size == 0? 1: 0;
1579                 return r == size;
1580         } else
1581 #endif
1582         {
1583                 int r = fread (ctx->buf, size, 1, ctx->file);
1584                 if (r == 0)
1585                         return size == 0? 1: 0;
1586                 return r;
1587         }
1588 }
1589
1590 static ThreadContext*
1591 get_thread (ProfContext *ctx, intptr_t thread_id)
1592 {
1593         ThreadContext *thread;
1594         if (ctx->current_thread && ctx->current_thread->thread_id == thread_id)
1595                 return ctx->current_thread;
1596         thread = ctx->threads;
1597         while (thread) {
1598                 if (thread->thread_id == thread_id) {
1599                         return thread;
1600                 }
1601                 thread = thread->next;
1602         }
1603         thread = (ThreadContext *)calloc (sizeof (ThreadContext), 1);
1604         thread->next = ctx->threads;
1605         ctx->threads = thread;
1606         thread->thread_id = thread_id;
1607         thread->last_time = 0;
1608         thread->stack_id = 0;
1609         thread->stack_size = 32;
1610         thread->stack = (MethodDesc **)malloc (thread->stack_size * sizeof (void*));
1611         thread->time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
1612         thread->callee_time_stack = (uint64_t *)malloc (thread->stack_size * sizeof (uint64_t));
1613         return thread;
1614 }
1615
1616 static DomainContext *
1617 get_domain (ProfContext *ctx, intptr_t domain_id)
1618 {
1619         if (ctx->current_domain && ctx->current_domain->domain_id == domain_id)
1620                 return ctx->current_domain;
1621
1622         DomainContext *domain = ctx->domains;
1623
1624         while (domain) {
1625                 if (domain->domain_id == domain_id)
1626                         return domain;
1627
1628                 domain = domain->next;
1629         }
1630
1631         domain = (DomainContext *)calloc (sizeof (DomainContext), 1);
1632         domain->next = ctx->domains;
1633         ctx->domains = domain;
1634         domain->domain_id = domain_id;
1635
1636         return domain;
1637 }
1638
1639 static RemCtxContext *
1640 get_remctx (ProfContext *ctx, intptr_t remctx_id)
1641 {
1642         if (ctx->current_remctx && ctx->current_remctx->remctx_id == remctx_id)
1643                 return ctx->current_remctx;
1644
1645         RemCtxContext *remctx = ctx->remctxs;
1646
1647         while (remctx) {
1648                 if (remctx->remctx_id == remctx_id)
1649                         return remctx;
1650
1651                 remctx = remctx->next;
1652         }
1653
1654         remctx = (RemCtxContext *)calloc (sizeof (RemCtxContext), 1);
1655         remctx->next = ctx->remctxs;
1656         ctx->remctxs = remctx;
1657         remctx->remctx_id = remctx_id;
1658
1659         return remctx;
1660 }
1661
1662 static ThreadContext*
1663 load_thread (ProfContext *ctx, intptr_t thread_id)
1664 {
1665         ThreadContext *thread = get_thread (ctx, thread_id);
1666         ctx->current_thread = thread;
1667         return thread;
1668 }
1669
1670 static void
1671 ensure_thread_stack (ThreadContext *thread)
1672 {
1673         if (thread->stack_id == thread->stack_size) {
1674                 thread->stack_size *= 2;
1675                 thread->stack = (MethodDesc **)realloc (thread->stack, thread->stack_size * sizeof (void*));
1676                 thread->time_stack = (uint64_t *)realloc (thread->time_stack, thread->stack_size * sizeof (uint64_t));
1677                 thread->callee_time_stack = (uint64_t *)realloc (thread->callee_time_stack, thread->stack_size * sizeof (uint64_t));
1678         }
1679 }
1680
1681 static int
1682 add_trace_hashed (CallContext *traces, int size, BackTrace *bt, uint64_t value)
1683 {
1684         int i;
1685         unsigned int start_pos;
1686         start_pos = bt->hash % size;
1687         i = start_pos;
1688         do {
1689                 if (traces [i].bt == bt) {
1690                         traces [i].count += value;
1691                         return 0;
1692                 } else if (!traces [i].bt) {
1693                         traces [i].bt = bt;
1694                         traces [i].count += value;
1695                         return 1;
1696                 }
1697                 /* wrap around */
1698                 if (++i == size)
1699                         i = 0;
1700         } while (i != start_pos);
1701         /* should not happen */
1702         printf ("failed trace store\n");
1703         return 0;
1704 }
1705
1706 static void
1707 add_trace_bt (BackTrace *bt, TraceDesc *trace, uint64_t value)
1708 {
1709         int i;
1710         if (!collect_traces)
1711                 return;
1712         if (trace->count * 2 >= trace->size) {
1713                 CallContext *n;
1714                 int old_size = trace->size;
1715                 trace->size *= 2;
1716                 if (trace->size == 0)
1717                         trace->size = 4;
1718                 n = (CallContext *)calloc (sizeof (CallContext) * trace->size, 1);
1719                 for (i = 0; i < old_size; ++i) {
1720                         if (trace->traces [i].bt)
1721                                 add_trace_hashed (n, trace->size, trace->traces [i].bt, trace->traces [i].count);
1722                 }
1723                 if (trace->traces)
1724                         free (trace->traces);
1725                 trace->traces = n;
1726         }
1727         trace->count += add_trace_hashed (trace->traces, trace->size, bt, value);
1728 }
1729
1730 static BackTrace*
1731 add_trace_thread (ThreadContext *thread, TraceDesc *trace, uint64_t value)
1732 {
1733         BackTrace *bt;
1734         int count = thread->stack_id;
1735         if (!collect_traces)
1736                 return NULL;
1737         if (count > trace_max)
1738                 count = trace_max;
1739         bt = add_backtrace (count, thread->stack + thread->stack_id - count);
1740         add_trace_bt (bt, trace, value);
1741         return bt;
1742 }
1743
1744 static BackTrace*
1745 add_trace_methods (MethodDesc **methods, int count, TraceDesc *trace, uint64_t value)
1746 {
1747         BackTrace *bt;
1748         if (!collect_traces)
1749                 return NULL;
1750         if (count > trace_max)
1751                 count = trace_max;
1752         bt = add_backtrace (count, methods);
1753         add_trace_bt (bt, trace, value);
1754         return bt;
1755 }
1756
1757 static void
1758 thread_add_root (ThreadContext *ctx, uintptr_t obj, int root_type, uintptr_t extra_info)
1759 {
1760         if (ctx->num_roots == ctx->size_roots) {
1761                 int new_size = ctx->size_roots * 2;
1762                 if (!new_size)
1763                         new_size = 4;
1764                 ctx->roots = (uintptr_t *)realloc (ctx->roots, new_size * sizeof (uintptr_t));
1765                 ctx->roots_extra = (uintptr_t *)realloc (ctx->roots_extra, new_size * sizeof (uintptr_t));
1766                 ctx->roots_types = (int *)realloc (ctx->roots_types, new_size * sizeof (int));
1767                 ctx->size_roots = new_size;
1768         }
1769         ctx->roots_types [ctx->num_roots] = root_type;
1770         ctx->roots_extra [ctx->num_roots] = extra_info;
1771         ctx->roots [ctx->num_roots++] = obj;
1772 }
1773
1774 static int
1775 compare_callc (const void *a, const void *b)
1776 {
1777         const CallContext *A = (const CallContext *)a;
1778         const CallContext *B = (const CallContext *)b;
1779         if (B->count == A->count)
1780                 return 0;
1781         if (B->count < A->count)
1782                 return -1;
1783         return 1;
1784 }
1785
1786 static void
1787 sort_context_array (TraceDesc* traces)
1788 {
1789         int i, j;
1790         for (i = 0, j = 0; i < traces->size; ++i) {
1791                 if (traces->traces [i].bt) {
1792                         traces->traces [j].bt = traces->traces [i].bt;
1793                         traces->traces [j].count = traces->traces [i].count;
1794                         j++;
1795                 }
1796         }
1797         qsort (traces->traces, traces->count, sizeof (CallContext), compare_callc);
1798 }
1799
1800 static void
1801 push_method (ThreadContext *thread, MethodDesc *method, uint64_t timestamp)
1802 {
1803         ensure_thread_stack (thread);
1804         thread->time_stack [thread->stack_id] = timestamp;
1805         thread->callee_time_stack [thread->stack_id] = 0;
1806         thread->stack [thread->stack_id++] = method;
1807         method->recurse_count++;
1808 }
1809
1810 static void
1811 pop_method (ThreadContext *thread, MethodDesc *method, uint64_t timestamp)
1812 {
1813         method->recurse_count--;
1814         if (thread->stack_id > 0 && thread->stack [thread->stack_id - 1] == method) {
1815                 uint64_t tdiff;
1816                 thread->stack_id--;
1817                 method->calls++;
1818                 if (timestamp < thread->time_stack [thread->stack_id])
1819                         fprintf (outfile, "time went backwards for %s\n", method->name);
1820                 tdiff = timestamp - thread->time_stack [thread->stack_id];
1821                 if (thread->callee_time_stack [thread->stack_id] > tdiff)
1822                         fprintf (outfile, "callee time bigger for %s\n", method->name);
1823                 method->self_time += tdiff - thread->callee_time_stack [thread->stack_id];
1824                 method->callee_time += thread->callee_time_stack [thread->stack_id];
1825                 if (thread->stack_id)
1826                         thread->callee_time_stack [thread->stack_id - 1] += tdiff;
1827                 //fprintf (outfile, "method %s took %d\n", method->name, (int)(tdiff/1000));
1828         } else {
1829                 fprintf (outfile, "unmatched leave at stack pos: %d for method %s\n", thread->stack_id, method->name);
1830         }
1831 }
1832
1833 typedef struct {
1834         uint64_t total_time;
1835         uint64_t max_time;
1836         int count;
1837 } GCDesc;
1838 static GCDesc gc_info [3];
1839 static uint64_t max_heap_size;
1840 static uint64_t gc_object_moves;
1841 static int gc_resizes;
1842 typedef struct {
1843         uint64_t created;
1844         uint64_t destroyed;
1845         uint64_t live;
1846         uint64_t max_live;
1847         TraceDesc traces;
1848         TraceDesc destroy_traces;
1849 } HandleInfo;
1850 static HandleInfo handle_info [4];
1851
1852 static const char*
1853 gc_event_name (int ev)
1854 {
1855         switch (ev) {
1856         case MONO_GC_EVENT_START: return "start";
1857         case MONO_GC_EVENT_MARK_START: return "mark start";
1858         case MONO_GC_EVENT_MARK_END: return "mark end";
1859         case MONO_GC_EVENT_RECLAIM_START: return "reclaim start";
1860         case MONO_GC_EVENT_RECLAIM_END: return "reclaim end";
1861         case MONO_GC_EVENT_END: return "end";
1862         case MONO_GC_EVENT_PRE_STOP_WORLD: return "pre stop";
1863         case MONO_GC_EVENT_POST_STOP_WORLD: return "post stop";
1864         case MONO_GC_EVENT_PRE_START_WORLD: return "pre start";
1865         case MONO_GC_EVENT_POST_START_WORLD: return "post start";
1866         default:
1867                 return "unknown";
1868         }
1869 }
1870
1871 static uint64_t clause_summary [MONO_EXCEPTION_CLAUSE_FAULT + 1];
1872 static uint64_t throw_count = 0;
1873 static TraceDesc exc_traces;
1874
1875 static const char*
1876 clause_name (int type)
1877 {
1878         switch (type) {
1879         case MONO_EXCEPTION_CLAUSE_NONE: return "catch";
1880         case MONO_EXCEPTION_CLAUSE_FILTER: return "filter";
1881         case MONO_EXCEPTION_CLAUSE_FINALLY: return "finally";
1882         case MONO_EXCEPTION_CLAUSE_FAULT: return "fault";
1883         default: return "invalid";
1884         }
1885 }
1886
1887 static uint64_t monitor_contention;
1888 static uint64_t monitor_failed;
1889 static uint64_t monitor_acquired;
1890
1891 struct _MonitorDesc {
1892         MonitorDesc *next;
1893         uintptr_t objid;
1894         uintptr_t contentions;
1895         uint64_t wait_time;
1896         uint64_t max_wait_time;
1897         TraceDesc traces;
1898 };
1899
1900 static MonitorDesc* monitor_hash [SMALL_HASH_SIZE] = {0};
1901 static int num_monitors = 0;
1902
1903 static MonitorDesc*
1904 lookup_monitor (uintptr_t objid)
1905 {
1906         int slot = ((objid >> 3) & 0xffff) % SMALL_HASH_SIZE;
1907         MonitorDesc *cd = monitor_hash [slot];
1908         while (cd && cd->objid != objid)
1909                 cd = cd->next;
1910         if (!cd) {
1911                 cd = (MonitorDesc *)calloc (sizeof (MonitorDesc), 1);
1912                 cd->objid = objid;
1913                 cd->next = monitor_hash [slot];
1914                 monitor_hash [slot] = cd;
1915                 num_monitors++;
1916         }
1917         return cd;
1918 }
1919
1920 static const char*
1921 monitor_ev_name (int ev)
1922 {
1923         switch (ev) {
1924         case MONO_PROFILER_MONITOR_CONTENTION: return "contended";
1925         case MONO_PROFILER_MONITOR_DONE: return "acquired";
1926         case MONO_PROFILER_MONITOR_FAIL: return "not taken";
1927         default: return "invalid";
1928         }
1929 }
1930
1931 static const char*
1932 get_handle_name (int htype)
1933 {
1934         switch (htype) {
1935         case 0: return "weak";
1936         case 1: return "weaktrack";
1937         case 2: return "normal";
1938         case 3: return "pinned";
1939         default: return "unknown";
1940         }
1941 }
1942
1943 static const char*
1944 get_root_name (int rtype)
1945 {
1946         switch (rtype & MONO_PROFILE_GC_ROOT_TYPEMASK) {
1947         case MONO_PROFILE_GC_ROOT_STACK: return "stack";
1948         case MONO_PROFILE_GC_ROOT_FINALIZER: return "finalizer";
1949         case MONO_PROFILE_GC_ROOT_HANDLE: return "handle";
1950         case MONO_PROFILE_GC_ROOT_OTHER: return "other";
1951         case MONO_PROFILE_GC_ROOT_MISC: return "misc";
1952         default: return "unknown";
1953         }
1954 }
1955
1956 static MethodDesc**
1957 decode_bt (MethodDesc** sframes, int *size, unsigned char *p, unsigned char **endp, intptr_t ptr_base)
1958 {
1959         MethodDesc **frames;
1960         int i;
1961         int flags = decode_uleb128 (p, &p);
1962         int count = decode_uleb128 (p, &p);
1963         if (flags != 0)
1964                 return NULL;
1965         if (count > *size)
1966                 frames = (MethodDesc **)malloc (count * sizeof (void*));
1967         else
1968                 frames = sframes;
1969         for (i = 0; i < count; ++i) {
1970                 intptr_t ptrdiff = decode_sleb128 (p, &p);
1971                 frames [i] = lookup_method (ptr_base + ptrdiff);
1972         }
1973         *size = count;
1974         *endp = p;
1975         return frames;
1976 }
1977
1978 static void
1979 tracked_creation (uintptr_t obj, ClassDesc *cd, uint64_t size, BackTrace *bt, uint64_t timestamp)
1980 {
1981         int i;
1982         for (i = 0; i < num_tracked_objects; ++i) {
1983                 if (tracked_objects [i] != obj)
1984                         continue;
1985                 fprintf (outfile, "Object %p created (%s, %llu bytes) at %.3f secs.\n", (void*)obj, cd->name, (unsigned long long) size, (timestamp - startup_time)/1000000000.0);
1986                 if (bt && bt->count) {
1987                         int k;
1988                         for (k = 0; k < bt->count; ++k)
1989                                 fprintf (outfile, "\t%s\n", bt->methods [k]->name);
1990                 }
1991         }
1992 }
1993
1994 static void
1995 track_handle (uintptr_t obj, int htype, uint32_t handle, BackTrace *bt, uint64_t timestamp)
1996 {
1997         int i;
1998         for (i = 0; i < num_tracked_objects; ++i) {
1999                 if (tracked_objects [i] != obj)
2000                         continue;
2001                 fprintf (outfile, "Object %p referenced from handle %u at %.3f secs.\n", (void*)obj, handle, (timestamp - startup_time) / 1000000000.0);
2002                 if (bt && bt->count) {
2003                         int k;
2004                         for (k = 0; k < bt->count; ++k)
2005                                 fprintf (outfile, "\t%s\n", bt->methods [k]->name);
2006                 }
2007         }
2008 }
2009
2010 static void
2011 track_move (uintptr_t src, uintptr_t dst)
2012 {
2013         int i;
2014         for (i = 0; i < num_tracked_objects; ++i) {
2015                 if (tracked_objects [i] == src)
2016                         fprintf (outfile, "Object %p moved to %p\n", (void*)src, (void*)dst);
2017                 else if (tracked_objects [i] == dst)
2018                         fprintf (outfile, "Object %p moved from %p\n", (void*)dst, (void*)src);
2019         }
2020 }
2021
2022 static void
2023 track_obj_reference (uintptr_t obj, uintptr_t parent, ClassDesc *cd)
2024 {
2025         int i;
2026         for (i = 0; i < num_tracked_objects; ++i) {
2027                 if (tracked_objects [i] == obj)
2028                         fprintf (outfile, "Object %p referenced from %p (%s).\n", (void*)obj, (void*)parent, cd->name);
2029         }
2030 }
2031
2032 static void
2033 found_object (uintptr_t obj)
2034 {
2035         num_tracked_objects ++;
2036         tracked_objects = (uintptr_t *)realloc (tracked_objects, num_tracked_objects * sizeof (tracked_objects [0]));
2037         tracked_objects [num_tracked_objects - 1] = obj;
2038 }
2039
2040 static int num_jit_helpers = 0;
2041 static int jit_helpers_code_size = 0;
2042
2043 static const char*
2044 code_buffer_desc (int type)
2045 {
2046         switch (type) {
2047         case MONO_PROFILER_CODE_BUFFER_METHOD:
2048                 return "method";
2049         case MONO_PROFILER_CODE_BUFFER_METHOD_TRAMPOLINE:
2050                 return "method trampoline";
2051         case MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE:
2052                 return "unbox trampoline";
2053         case MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE:
2054                 return "imt trampoline";
2055         case MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE:
2056                 return "generics trampoline";
2057         case MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE:
2058                 return "specific trampoline";
2059         case MONO_PROFILER_CODE_BUFFER_HELPER:
2060                 return "misc helper";
2061         case MONO_PROFILER_CODE_BUFFER_MONITOR:
2062                 return "monitor/lock";
2063         case MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE:
2064                 return "delegate invoke";
2065         case MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING:
2066                 return "exception handling";
2067         default:
2068                 return "unspecified";
2069         }
2070 }
2071
2072 typedef struct _CoverageAssembly CoverageAssembly;
2073 struct _CoverageAssembly {
2074         char *name;
2075         char *guid;
2076         char *filename;
2077         int number_of_methods;
2078         int fully_covered;
2079         int partially_covered;
2080 };
2081
2082 typedef struct _CoverageClass CoverageClass;
2083 struct _CoverageClass {
2084         char *assembly_name;
2085         char *class_name;
2086         int number_of_methods;
2087         int fully_covered;
2088         int partially_covered;
2089 };
2090
2091 typedef struct _CoverageCoverage CoverageCoverage;
2092 struct _CoverageCoverage {
2093         int method_id;
2094         int offset;
2095         int count;
2096         int line;
2097         int column;
2098 };
2099
2100 typedef struct _CoverageMethod CoverageMethod;
2101 struct _CoverageMethod {
2102         char *assembly_name;
2103         char *class_name;
2104         char *method_name;
2105         char *method_signature;
2106         char *filename;
2107         int token;
2108         int n_statements;
2109         int method_id;
2110         GPtrArray *coverage;
2111 };
2112 static GPtrArray *coverage_assemblies = NULL;
2113 static GPtrArray *coverage_methods = NULL;
2114 static GPtrArray *coverage_statements = NULL;
2115 static GHashTable *coverage_methods_hash = NULL;
2116 static GPtrArray *coverage_classes = NULL;
2117 static GHashTable *coverage_assembly_classes = NULL;
2118
2119 static void
2120 gather_coverage_statements (void)
2121 {
2122         for (guint i = 0; i < coverage_statements->len; i++) {
2123                 CoverageCoverage *coverage = (CoverageCoverage *)coverage_statements->pdata[i];
2124                 CoverageMethod *method = (CoverageMethod *)g_hash_table_lookup (coverage_methods_hash, GINT_TO_POINTER (coverage->method_id));
2125                 if (method == NULL) {
2126                         fprintf (outfile, "Cannot find method with ID: %d\n", coverage->method_id);
2127                         continue;
2128                 }
2129
2130                 g_ptr_array_add (method->coverage, coverage);
2131         }
2132 }
2133
2134 static void
2135 coverage_add_assembly (CoverageAssembly *assembly)
2136 {
2137         if (coverage_assemblies == NULL)
2138                 coverage_assemblies = g_ptr_array_new ();
2139
2140         g_ptr_array_add (coverage_assemblies, assembly);
2141 }
2142
2143 static void
2144 coverage_add_method (CoverageMethod *method)
2145 {
2146         if (coverage_methods == NULL) {
2147                 coverage_methods = g_ptr_array_new ();
2148                 coverage_methods_hash = g_hash_table_new (NULL, NULL);
2149         }
2150
2151         g_ptr_array_add (coverage_methods, method);
2152         g_hash_table_insert (coverage_methods_hash, GINT_TO_POINTER (method->method_id), method);
2153 }
2154
2155 static void
2156 coverage_add_class (CoverageClass *klass)
2157 {
2158         GPtrArray *classes = NULL;
2159
2160         if (coverage_classes == NULL) {
2161                 coverage_classes = g_ptr_array_new ();
2162                 coverage_assembly_classes = g_hash_table_new (g_str_hash, g_str_equal);
2163         }
2164
2165         g_ptr_array_add (coverage_classes, klass);
2166         classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, klass->assembly_name);
2167         if (classes == NULL) {
2168                 classes = g_ptr_array_new ();
2169                 g_hash_table_insert (coverage_assembly_classes, klass->assembly_name, classes);
2170         }
2171         g_ptr_array_add (classes, klass);
2172 }
2173
2174 static void
2175 coverage_add_coverage (CoverageCoverage *coverage)
2176 {
2177         if (coverage_statements == NULL)
2178                 coverage_statements = g_ptr_array_new ();
2179
2180         g_ptr_array_add (coverage_statements, coverage);
2181 }
2182
2183 #define OBJ_ADDR(diff) ((obj_base + diff) << 3)
2184 #define LOG_TIME(base,diff) /*fprintf("outfile, time %llu + %llu near offset %d\n", base, diff, p - ctx->buf)*/
2185
2186
2187 /* Stats */
2188 #define BUFFER_HEADER_SIZE 48
2189
2190 typedef struct {
2191         int count, min_size, max_size, bytes;
2192 } EventStat;
2193
2194 static int buffer_count;
2195 static EventStat stats [256];
2196
2197 static void
2198 record_event_stats (int type, int size)
2199 {
2200         ++stats [type].count;
2201         if (!stats [type].min_size)
2202                 stats [type].min_size = size;
2203         stats [type].min_size = MIN (stats [type].min_size, size);
2204         stats [type].max_size = MAX (stats [type].max_size, size);
2205         stats [type].bytes += size;
2206 }
2207
2208 static int
2209 decode_buffer (ProfContext *ctx)
2210 {
2211         unsigned char *p;
2212         unsigned char *end;
2213         intptr_t thread_id;
2214         intptr_t ptr_base;
2215         intptr_t obj_base;
2216         intptr_t method_base;
2217         uint64_t time_base;
2218         uint64_t file_offset;
2219         int len, i;
2220         ThreadContext *thread;
2221
2222 #ifdef HAVE_SYS_ZLIB
2223         if (ctx->gzfile)
2224                 file_offset = gztell (ctx->gzfile);
2225         else
2226 #endif
2227                 file_offset = ftell (ctx->file);
2228         if (!load_data (ctx, 48))
2229                 return 0;
2230         p = ctx->buf;
2231         if (read_int32 (p) != BUF_ID) {
2232                 fprintf (outfile, "Incorrect buffer id: 0x%x\n", read_int32 (p));
2233                 for (i = 0; i < 48; ++i) {
2234                         fprintf (outfile, "0x%x%s", p [i], i % 8?" ":"\n");
2235                 }
2236                 return 0;
2237         }
2238         len = read_int32 (p + 4);
2239         time_base = read_int64 (p + 8);
2240         ptr_base = read_int64 (p + 16);
2241         obj_base = read_int64 (p + 24);
2242         thread_id = read_int64 (p + 32);
2243         method_base = read_int64 (p + 40);
2244         if (debug)
2245                 fprintf (outfile, "buf: thread:%zx, len: %d, time: %llu, file offset: %llu\n", thread_id, len, (unsigned long long) time_base, (unsigned long long) file_offset);
2246         thread = load_thread (ctx, thread_id);
2247         if (!load_data (ctx, len))
2248                 return 0;
2249
2250         ++buffer_count;
2251
2252         if (!startup_time) {
2253                 startup_time = time_base;
2254                 if (use_time_filter) {
2255                         time_from += startup_time;
2256                         time_to += startup_time;
2257                 }
2258                 if (!thread->name)
2259                         thread->name = pstrdup ("Main");
2260         }
2261         for (i = 0; i < thread->stack_id; ++i)
2262                 thread->stack [i]->recurse_count++;
2263         p = ctx->buf;
2264         end = p + len;
2265         while (p < end) {
2266                 unsigned char *start = p;
2267                 unsigned char event = *p;
2268                 switch (*p & 0xf) {
2269                 case TYPE_GC: {
2270                         int subtype = *p & 0xf0;
2271                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2272                         LOG_TIME (time_base, tdiff);
2273                         time_base += tdiff;
2274                         if (subtype == TYPE_GC_RESIZE) {
2275                                 uint64_t new_size = decode_uleb128 (p, &p);
2276                                 if (debug)
2277                                         fprintf (outfile, "gc heap resized to %llu\n", (unsigned long long) new_size);
2278                                 gc_resizes++;
2279                                 if (new_size > max_heap_size)
2280                                         max_heap_size = new_size;
2281                         } else if (subtype == TYPE_GC_EVENT) {
2282                                 uint64_t ev = decode_uleb128 (p, &p);
2283                                 int gen = decode_uleb128 (p, &p);
2284                                 if (debug)
2285                                         fprintf (outfile, "gc event for gen%d: %s at %llu (thread: 0x%zx)\n", gen, gc_event_name (ev), (unsigned long long) time_base, thread->thread_id);
2286                                 if (gen > 2) {
2287                                         fprintf (outfile, "incorrect gc gen: %d\n", gen);
2288                                         break;
2289                                 }
2290                                 if (ev == MONO_GC_EVENT_START) {
2291                                         thread->gc_start_times [gen] = time_base;
2292                                         gc_info [gen].count++;
2293                                 } else if (ev == MONO_GC_EVENT_END) {
2294                                         tdiff = time_base - thread->gc_start_times [gen];
2295                                         gc_info [gen].total_time += tdiff;
2296                                         if (tdiff > gc_info [gen].max_time)
2297                                                 gc_info [gen].max_time = tdiff;
2298                                 }
2299                         } else if (subtype == TYPE_GC_MOVE) {
2300                                 int j, num = decode_uleb128 (p, &p);
2301                                 gc_object_moves += num / 2;
2302                                 for (j = 0; j < num; j += 2) {
2303                                         intptr_t obj1diff = decode_sleb128 (p, &p);
2304                                         intptr_t obj2diff = decode_sleb128 (p, &p);
2305                                         if (num_tracked_objects)
2306                                                 track_move (OBJ_ADDR (obj1diff), OBJ_ADDR (obj2diff));
2307                                         if (debug) {
2308                                                 fprintf (outfile, "moved obj %p to %p\n", (void*)OBJ_ADDR (obj1diff), (void*)OBJ_ADDR (obj2diff));
2309                                         }
2310                                 }
2311                         } else if (subtype == TYPE_GC_HANDLE_CREATED || subtype == TYPE_GC_HANDLE_CREATED_BT) {
2312                                 int has_bt = subtype == TYPE_GC_HANDLE_CREATED_BT;
2313                                 int num_bt = 0;
2314                                 MethodDesc *sframes [8];
2315                                 MethodDesc **frames = sframes;
2316                                 int htype = decode_uleb128 (p, &p);
2317                                 uint32_t handle = decode_uleb128 (p, &p);
2318                                 intptr_t objdiff = decode_sleb128 (p, &p);
2319                                 if (has_bt) {
2320                                         num_bt = 8;
2321                                         frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2322                                         if (!frames) {
2323                                                 fprintf (outfile, "Cannot load backtrace\n");
2324                                                 return 0;
2325                                         }
2326                                 }
2327                                 if (htype > 3)
2328                                         return 0;
2329                                 if ((thread_filter && thread_filter == thread->thread_id) || (time_base >= time_from && time_base < time_to)) {
2330                                         handle_info [htype].created++;
2331                                         handle_info [htype].live++;
2332                                         if (handle_info [htype].live > handle_info [htype].max_live)
2333                                                 handle_info [htype].max_live = handle_info [htype].live;
2334                                         BackTrace *bt;
2335                                         if (has_bt)
2336                                                 bt = add_trace_methods (frames, num_bt, &handle_info [htype].traces, 1);
2337                                         else
2338                                                 bt = add_trace_thread (thread, &handle_info [htype].traces, 1);
2339                                         if (num_tracked_objects)
2340                                                 track_handle (OBJ_ADDR (objdiff), htype, handle, bt, time_base);
2341                                 }
2342                                 if (debug)
2343                                         fprintf (outfile, "handle (%s) %u created for object %p\n", get_handle_name (htype), handle, (void*)OBJ_ADDR (objdiff));
2344                                 if (frames != sframes)
2345                                         free (frames);
2346                         } else if (subtype == TYPE_GC_HANDLE_DESTROYED || subtype == TYPE_GC_HANDLE_DESTROYED_BT) {
2347                                 int has_bt = subtype == TYPE_GC_HANDLE_DESTROYED_BT;
2348                                 int num_bt = 0;
2349                                 MethodDesc *sframes [8];
2350                                 MethodDesc **frames = sframes;
2351                                 int htype = decode_uleb128 (p, &p);
2352                                 uint32_t handle = decode_uleb128 (p, &p);
2353                                 if (has_bt) {
2354                                         num_bt = 8;
2355                                         frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2356                                         if (!frames) {
2357                                                 fprintf (outfile, "Cannot load backtrace\n");
2358                                                 return 0;
2359                                         }
2360                                 }
2361                                 if (htype > 3)
2362                                         return 0;
2363                                 if ((thread_filter && thread_filter == thread->thread_id) || (time_base >= time_from && time_base < time_to)) {
2364                                         handle_info [htype].destroyed ++;
2365                                         handle_info [htype].live--;
2366                                         BackTrace *bt;
2367                                         if (has_bt)
2368                                                 bt = add_trace_methods (frames, num_bt, &handle_info [htype].destroy_traces, 1);
2369                                         else
2370                                                 bt = add_trace_thread (thread, &handle_info [htype].destroy_traces, 1);
2371                                         /* TODO: track_handle_free () - would need to record and keep track of the associated object address... */
2372                                 }
2373                                 if (debug)
2374                                         fprintf (outfile, "handle (%s) %u destroyed\n", get_handle_name (htype), handle);
2375                                 if (frames != sframes)
2376                                         free (frames);
2377                         }
2378                         break;
2379                 }
2380                 case TYPE_METADATA: {
2381                         int subtype = *p & 0xf0;
2382                         const char *load_str = subtype == TYPE_END_LOAD ? "loaded" : "unloaded";
2383                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2384                         int mtype = *p++;
2385                         intptr_t ptrdiff = decode_sleb128 (p, &p);
2386                         LOG_TIME (time_base, tdiff);
2387                         time_base += tdiff;
2388                         if (mtype == TYPE_CLASS) {
2389                                 intptr_t imptrdiff = decode_sleb128 (p, &p);
2390                                 uint64_t flags = decode_uleb128 (p, &p);
2391                                 if (flags) {
2392                                         fprintf (outfile, "non-zero flags in class\n");
2393                                         return 0;
2394                                 }
2395                                 if (debug)
2396                                         fprintf (outfile, "%s class %p (%s in %p) at %llu\n", load_str, (void*)(ptr_base + ptrdiff), p, (void*)(ptr_base + imptrdiff), (unsigned long long) time_base);
2397                                 if (subtype == TYPE_END_LOAD)
2398                                         add_class (ptr_base + ptrdiff, (char*)p);
2399                                 while (*p) p++;
2400                                 p++;
2401                         } else if (mtype == TYPE_IMAGE) {
2402                                 uint64_t flags = decode_uleb128 (p, &p);
2403                                 if (flags) {
2404                                         fprintf (outfile, "non-zero flags in image\n");
2405                                         return 0;
2406                                 }
2407                                 if (debug)
2408                                         fprintf (outfile, "%s image %p (%s) at %llu\n", load_str, (void*)(ptr_base + ptrdiff), p, (unsigned long long) time_base);
2409                                 if (subtype == TYPE_END_LOAD)
2410                                         add_image (ptr_base + ptrdiff, (char*)p);
2411                                 while (*p) p++;
2412                                 p++;
2413                         } else if (mtype == TYPE_ASSEMBLY) {
2414                                 uint64_t flags = decode_uleb128 (p, &p);
2415                                 if (flags) {
2416                                         fprintf (outfile, "non-zero flags in assembly\n");
2417                                         return 0;
2418                                 }
2419                                 if (debug)
2420                                         fprintf (outfile, "%s assembly %p (%s) at %llu\n", load_str, (void*)(ptr_base + ptrdiff), p, (unsigned long long) time_base);
2421                                 if (subtype == TYPE_END_LOAD)
2422                                         add_assembly (ptr_base + ptrdiff, (char*)p);
2423                                 while (*p) p++;
2424                                 p++;
2425                         } else if (mtype == TYPE_DOMAIN) {
2426                                 uint64_t flags = decode_uleb128 (p, &p);
2427                                 if (flags) {
2428                                         fprintf (outfile, "non-zero flags in domain\n");
2429                                         return 0;
2430                                 }
2431                                 DomainContext *nd = get_domain (ctx, ptr_base + ptrdiff);
2432                                 /* no subtype means it's a name event, rather than start/stop */
2433                                 if (subtype == 0)
2434                                         nd->friendly_name = pstrdup ((char *) p);
2435                                 if (debug) {
2436                                         if (subtype == 0)
2437                                                 fprintf (outfile, "domain %p named at %llu: %s\n", (void *) (ptr_base + ptrdiff), (unsigned long long) time_base, p);
2438                                         else
2439                                                 fprintf (outfile, "%s thread %p at %llu\n", load_str, (void *) (ptr_base + ptrdiff), (unsigned long long) time_base);
2440                                 }
2441                                 if (subtype == 0) {
2442                                         while (*p) p++;
2443                                         p++;
2444                                 }
2445                         } else if (mtype == TYPE_CONTEXT) {
2446                                 uint64_t flags = decode_uleb128 (p, &p);
2447                                 if (flags) {
2448                                         fprintf (outfile, "non-zero flags in context\n");
2449                                         return 0;
2450                                 }
2451                                 intptr_t domaindiff = decode_sleb128 (p, &p);
2452                                 if (debug)
2453                                         fprintf (outfile, "%s context %p (%p) at %llu\n", load_str, (void*)(ptr_base + ptrdiff), (void *) (ptr_base + domaindiff), (unsigned long long) time_base);
2454                                 if (subtype == TYPE_END_LOAD)
2455                                         get_remctx (ctx, ptr_base + ptrdiff)->domain_id = ptr_base + domaindiff;
2456                         } else if (mtype == TYPE_THREAD) {
2457                                 uint64_t flags = decode_uleb128 (p, &p);
2458                                 if (flags) {
2459                                         fprintf (outfile, "non-zero flags in thread\n");
2460                                         return 0;
2461                                 }
2462                                 ThreadContext *nt = get_thread (ctx, ptr_base + ptrdiff);
2463                                 /* no subtype means it's a name event, rather than start/stop */
2464                                 if (subtype == 0)
2465                                         nt->name = pstrdup ((char*)p);
2466                                 if (debug) {
2467                                         if (subtype == 0)
2468                                                 fprintf (outfile, "thread %p named at %llu: %s\n", (void*)(ptr_base + ptrdiff), (unsigned long long) time_base, p);
2469                                         else
2470                                                 fprintf (outfile, "%s thread %p at %llu\n", load_str, (void *) (ptr_base + ptrdiff), (unsigned long long) time_base);
2471                                 }
2472                                 if (subtype == 0) {
2473                                         while (*p) p++;
2474                                         p++;
2475                                 }
2476                         }
2477                         break;
2478                 }
2479                 case TYPE_ALLOC: {
2480                         int has_bt = *p & TYPE_ALLOC_BT;
2481                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2482                         intptr_t ptrdiff = decode_sleb128 (p, &p);
2483                         intptr_t objdiff = decode_sleb128 (p, &p);
2484                         uint64_t len;
2485                         int num_bt = 0;
2486                         MethodDesc* sframes [8];
2487                         MethodDesc** frames = sframes;
2488                         ClassDesc *cd = lookup_class (ptr_base + ptrdiff);
2489                         len = decode_uleb128 (p, &p);
2490                         LOG_TIME (time_base, tdiff);
2491                         time_base += tdiff;
2492                         if (debug)
2493                                 fprintf (outfile, "alloced object %p, size %llu (%s) at %llu\n", (void*)OBJ_ADDR (objdiff), (unsigned long long) len, lookup_class (ptr_base + ptrdiff)->name, (unsigned long long) time_base);
2494                         if (has_bt) {
2495                                 num_bt = 8;
2496                                 frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2497                                 if (!frames) {
2498                                         fprintf (outfile, "Cannot load backtrace\n");
2499                                         return 0;
2500                                 }
2501                         }
2502                         if ((thread_filter && thread_filter == thread->thread_id) || (time_base >= time_from && time_base < time_to)) {
2503                                 BackTrace *bt;
2504                                 cd->allocs++;
2505                                 cd->alloc_size += len;
2506                                 if (has_bt)
2507                                         bt = add_trace_methods (frames, num_bt, &cd->traces, len);
2508                                 else
2509                                         bt = add_trace_thread (thread, &cd->traces, len);
2510                                 if (find_size && len >= find_size) {
2511                                         if (!find_name || strstr (cd->name, find_name))
2512                                                 found_object (OBJ_ADDR (objdiff));
2513                                 } else if (!find_size && find_name && strstr (cd->name, find_name)) {
2514                                         found_object (OBJ_ADDR (objdiff));
2515                                 }
2516                                 if (num_tracked_objects)
2517                                         tracked_creation (OBJ_ADDR (objdiff), cd, len, bt, time_base);
2518                         }
2519                         if (frames != sframes)
2520                                 free (frames);
2521                         break;
2522                 }
2523                 case TYPE_METHOD: {
2524                         int subtype = *p & 0xf0;
2525                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2526                         int64_t ptrdiff = decode_sleb128 (p, &p);
2527                         LOG_TIME (time_base, tdiff);
2528                         time_base += tdiff;
2529                         method_base += ptrdiff;
2530                         if (subtype == TYPE_JIT) {
2531                                 intptr_t codediff = decode_sleb128 (p, &p);
2532                                 int codelen = decode_uleb128 (p, &p);
2533                                 MethodDesc *jitted_method;
2534                                 if (debug)
2535                                         fprintf (outfile, "jitted method %p (%s), size: %d, code: %p\n", (void*)(method_base), p, codelen, (void*)(ptr_base + codediff));
2536                                 jitted_method = add_method (method_base, (char*)p, ptr_base + codediff, codelen);
2537                                 if (!(time_base >= time_from && time_base < time_to))
2538                                         jitted_method->ignore_jit = 1;
2539                                 while (*p) p++;
2540                                 p++;
2541                         } else {
2542                                 MethodDesc *method;
2543                                 if ((thread_filter && thread_filter != thread->thread_id))
2544                                         break;
2545                                 if (!(time_base >= time_from && time_base < time_to))
2546                                         break;
2547                                 method = lookup_method (method_base);
2548                                 if (subtype == TYPE_ENTER) {
2549                                         add_trace_thread (thread, &method->traces, 1);
2550                                         push_method (thread, method, time_base);
2551                                 } else {
2552                                         pop_method (thread, method, time_base);
2553                                 }
2554                                 if (debug)
2555                                         fprintf (outfile, "%s method %s\n", subtype == TYPE_ENTER? "enter": subtype == TYPE_EXC_LEAVE? "exleave": "leave", method->name);
2556                         }
2557                         break;
2558                 }
2559                 case TYPE_HEAP: {
2560                         int subtype = *p & 0xf0;
2561                         if (subtype == TYPE_HEAP_OBJECT) {
2562                                 HeapObjectDesc *ho = NULL;
2563                                 int i;
2564                                 intptr_t objdiff = decode_sleb128 (p + 1, &p);
2565                                 intptr_t ptrdiff = decode_sleb128 (p, &p);
2566                                 uint64_t size = decode_uleb128 (p, &p);
2567                                 uintptr_t num = decode_uleb128 (p, &p);
2568                                 uintptr_t ref_offset = 0;
2569                                 uintptr_t last_obj_offset = 0;
2570                                 ClassDesc *cd = lookup_class (ptr_base + ptrdiff);
2571                                 if (size) {
2572                                         HeapClassDesc *hcd = add_heap_shot_class (thread->current_heap_shot, cd, size);
2573                                         if (collect_traces) {
2574                                                 ho = alloc_heap_obj (OBJ_ADDR (objdiff), hcd, num);
2575                                                 add_heap_shot_obj (thread->current_heap_shot, ho);
2576                                                 ref_offset = 0;
2577                                         }
2578                                 } else {
2579                                         if (collect_traces)
2580                                                 ho = heap_shot_obj_add_refs (thread->current_heap_shot, OBJ_ADDR (objdiff), num, &ref_offset);
2581                                 }
2582                                 for (i = 0; i < num; ++i) {
2583                                         /* FIXME: use object distance to measure how good
2584                                          * the GC is at keeping related objects close
2585                                          */
2586                                         uintptr_t offset = ctx->data_version > 1? last_obj_offset + decode_uleb128 (p, &p): -1;
2587                                         intptr_t obj1diff = decode_sleb128 (p, &p);
2588                                         last_obj_offset = offset;
2589                                         if (collect_traces)
2590                                                 ho->refs [ref_offset + i] = OBJ_ADDR (obj1diff);
2591                                         if (num_tracked_objects)
2592                                                 track_obj_reference (OBJ_ADDR (obj1diff), OBJ_ADDR (objdiff), cd);
2593                                 }
2594                                 if (debug && size)
2595                                         fprintf (outfile, "traced object %p, size %llu (%s), refs: %zd\n", (void*)OBJ_ADDR (objdiff), (unsigned long long) size, cd->name, num);
2596                         } else if (subtype == TYPE_HEAP_ROOT) {
2597                                 uintptr_t num = decode_uleb128 (p + 1, &p);
2598                                 uintptr_t gc_num G_GNUC_UNUSED = decode_uleb128 (p, &p);
2599                                 int i;
2600                                 for (i = 0; i < num; ++i) {
2601                                         intptr_t objdiff = decode_sleb128 (p, &p);
2602                                         int root_type = decode_uleb128 (p, &p);
2603                                         /* we just discard the extra info for now */
2604                                         uintptr_t extra_info = decode_uleb128 (p, &p);
2605                                         if (debug)
2606                                                 fprintf (outfile, "object %p is a %s root\n", (void*)OBJ_ADDR (objdiff), get_root_name (root_type));
2607                                         if (collect_traces)
2608                                                 thread_add_root (thread, OBJ_ADDR (objdiff), root_type, extra_info);
2609                                 }
2610                         } else if (subtype == TYPE_HEAP_END) {
2611                                 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2612                                 LOG_TIME (time_base, tdiff);
2613                                 time_base += tdiff;
2614                                 if (debug)
2615                                         fprintf (outfile, "heap shot end\n");
2616                                 if (collect_traces) {
2617                                         HeapShot *hs = thread->current_heap_shot;
2618                                         if (hs && thread->num_roots) {
2619                                                 /* transfer the root ownershipt to the heapshot */
2620                                                 hs->num_roots = thread->num_roots;
2621                                                 hs->roots = thread->roots;
2622                                                 hs->roots_extra = thread->roots_extra;
2623                                                 hs->roots_types = thread->roots_types;
2624                                         } else {
2625                                                 free (thread->roots);
2626                                                 free (thread->roots_extra);
2627                                                 free (thread->roots_types);
2628                                         }
2629                                         thread->num_roots = 0;
2630                                         thread->size_roots = 0;
2631                                         thread->roots = NULL;
2632                                         thread->roots_extra = NULL;
2633                                         thread->roots_types = NULL;
2634                                         heap_shot_resolve_reverse_refs (hs);
2635                                         heap_shot_mark_objects (hs);
2636                                         heap_shot_free_objects (hs);
2637                                 }
2638                                 thread->current_heap_shot = NULL;
2639                         } else if (subtype == TYPE_HEAP_START) {
2640                                 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2641                                 LOG_TIME (time_base, tdiff);
2642                                 time_base += tdiff;
2643                                 if (debug)
2644                                         fprintf (outfile, "heap shot start\n");
2645                                 thread->current_heap_shot = new_heap_shot (time_base);
2646                         }
2647                         break;
2648                 }
2649                 case TYPE_MONITOR: {
2650                         int event = (*p >> 4) & 0x3;
2651                         int has_bt = *p & TYPE_MONITOR_BT;
2652                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2653                         intptr_t objdiff = decode_sleb128 (p, &p);
2654                         MethodDesc* sframes [8];
2655                         MethodDesc** frames = sframes;
2656                         int record;
2657                         int num_bt = 0;
2658                         LOG_TIME (time_base, tdiff);
2659                         time_base += tdiff;
2660                         record = (!thread_filter || thread_filter == thread->thread_id);
2661                         if (!(time_base >= time_from && time_base < time_to))
2662                                 record = 0;
2663                         if (event == MONO_PROFILER_MONITOR_CONTENTION) {
2664                                 MonitorDesc *mdesc = lookup_monitor (OBJ_ADDR (objdiff));
2665                                 if (record) {
2666                                         monitor_contention++;
2667                                         mdesc->contentions++;
2668                                         thread->monitor = mdesc;
2669                                         thread->contention_start = time_base;
2670                                 }
2671                                 if (has_bt) {
2672                                         num_bt = 8;
2673                                         frames = decode_bt (sframes, &num_bt, p, &p, ptr_base);
2674                                         if (!frames) {
2675                                                 fprintf (outfile, "Cannot load backtrace\n");
2676                                                 return 0;
2677                                         }
2678                                         if (record)
2679                                                 add_trace_methods (frames, num_bt, &mdesc->traces, 1);
2680                                 } else {
2681                                         if (record)
2682                                                 add_trace_thread (thread, &mdesc->traces, 1);
2683                                 }
2684                         } else if (event == MONO_PROFILER_MONITOR_FAIL) {
2685                                 if (record) {
2686                                         monitor_failed++;
2687                                         if (thread->monitor && thread->contention_start) {
2688                                                 uint64_t wait_time = time_base - thread->contention_start;
2689                                                 if (wait_time > thread->monitor->max_wait_time)
2690                                                         thread->monitor->max_wait_time = wait_time;
2691                                                 thread->monitor->wait_time += wait_time;
2692                                                 thread->monitor = NULL;
2693                                                 thread->contention_start = 0;
2694                                         }
2695                                 }
2696                         } else if (event == MONO_PROFILER_MONITOR_DONE) {
2697                                 if (record) {
2698                                         monitor_acquired++;
2699                                         if (thread->monitor && thread->contention_start) {
2700                                                 uint64_t wait_time = time_base - thread->contention_start;
2701                                                 if (wait_time > thread->monitor->max_wait_time)
2702                                                         thread->monitor->max_wait_time = wait_time;
2703                                                 thread->monitor->wait_time += wait_time;
2704                                                 thread->monitor = NULL;
2705                                                 thread->contention_start = 0;
2706                                         }
2707                                 }
2708                         }
2709                         if (debug)
2710                                 fprintf (outfile, "monitor %s for object %p\n", monitor_ev_name (event), (void*)OBJ_ADDR (objdiff));
2711                         if (frames != sframes)
2712                                 free (frames);
2713                         break;
2714                 }
2715                 case TYPE_EXCEPTION: {
2716                         int subtype = *p & 0x70;
2717                         int has_bt = *p & TYPE_EXCEPTION_BT;
2718                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2719                         MethodDesc* sframes [8];
2720                         MethodDesc** frames = sframes;
2721                         int record;
2722                         LOG_TIME (time_base, tdiff);
2723                         time_base += tdiff;
2724                         record = (!thread_filter || thread_filter == thread->thread_id);
2725                         if (!(time_base >= time_from && time_base < time_to))
2726                                 record = 0;
2727                         if (subtype == TYPE_CLAUSE) {
2728                                 int clause_type = decode_uleb128 (p, &p);
2729                                 int clause_num = decode_uleb128 (p, &p);
2730                                 int64_t ptrdiff = decode_sleb128 (p, &p);
2731                                 method_base += ptrdiff;
2732                                 if (record)
2733                                         clause_summary [clause_type]++;
2734                                 if (debug)
2735                                         fprintf (outfile, "clause %s (%d) in method %s\n", clause_name (clause_type), clause_num, lookup_method (method_base)->name);
2736                         } else {
2737                                 intptr_t objdiff = decode_sleb128 (p, &p);
2738                                 if (record)
2739                                         throw_count++;
2740                                 if (has_bt) {
2741                                         has_bt = 8;
2742                                         frames = decode_bt (sframes, &has_bt, p, &p, ptr_base);
2743                                         if (!frames) {
2744                                                 fprintf (outfile, "Cannot load backtrace\n");
2745                                                 return 0;
2746                                         }
2747                                         if (record)
2748                                                 add_trace_methods (frames, has_bt, &exc_traces, 1);
2749                                 } else {
2750                                         if (record)
2751                                                 add_trace_thread (thread, &exc_traces, 1);
2752                                 }
2753                                 if (frames != sframes)
2754                                         free (frames);
2755                                 if (debug)
2756                                         fprintf (outfile, "throw %p\n", (void*)OBJ_ADDR (objdiff));
2757                         }
2758                         break;
2759                 }
2760                 case TYPE_RUNTIME: {
2761                         int subtype = *p & 0xf0;
2762                         uint64_t tdiff = decode_uleb128 (p + 1, &p);
2763                         LOG_TIME (time_base, tdiff);
2764                         time_base += tdiff;
2765                         if (subtype == TYPE_JITHELPER) {
2766                                 int type = decode_uleb128 (p, &p);
2767                                 intptr_t codediff = decode_sleb128 (p, &p);
2768                                 int codelen = decode_uleb128 (p, &p);
2769                                 const char *name;
2770                                 if (type == MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE) {
2771                                         name = (const char *)p;
2772                                         while (*p) p++;
2773                                                 p++;
2774                                 } else {
2775                                         name = code_buffer_desc (type);
2776                                 }
2777                                 num_jit_helpers++;
2778                                 jit_helpers_code_size += codelen;
2779                                 if (debug)
2780                                         fprintf (outfile, "jit helper %s, size: %d, code: %p\n", name, codelen, (void*)(ptr_base + codediff));
2781                         }
2782                         break;
2783                 }
2784                 case TYPE_SAMPLE: {
2785                         int subtype = *p & 0xf0;
2786                         if (subtype == TYPE_SAMPLE_HIT) {
2787                                 int i;
2788                                 int sample_type = decode_uleb128 (p + 1, &p);
2789                                 uint64_t tstamp = decode_uleb128 (p, &p);
2790                                 void *tid = (void *) thread_id;
2791                                 if (ctx->data_version > 10)
2792                                         tid = (void *) (ptr_base + decode_sleb128 (p, &p));
2793                                 int count = decode_uleb128 (p, &p);
2794                                 for (i = 0; i < count; ++i) {
2795                                         uintptr_t ip = ptr_base + decode_sleb128 (p, &p);
2796                                         if ((tstamp >= time_from && tstamp < time_to))
2797                                                 add_stat_sample (sample_type, ip);
2798                                         if (debug)
2799                                                 fprintf (outfile, "sample hit, type: %d at %p for thread %p\n", sample_type, (void*)ip, tid);
2800                                 }
2801                                 if (ctx->data_version > 5) {
2802                                         count = decode_uleb128 (p, &p);
2803                                         for (i = 0; i < count; ++i) {
2804                                                 MethodDesc *method;
2805                                                 int64_t ptrdiff = decode_sleb128 (p, &p);
2806                                                 int il_offset = decode_sleb128 (p, &p);
2807                                                 int native_offset = decode_sleb128 (p, &p);
2808                                                 method_base += ptrdiff;
2809                                                 method = lookup_method (method_base);
2810                                                 if (debug)
2811                                                         fprintf (outfile, "sample hit bt %d: %s at IL offset %d (native: %d)\n", i, method->name, il_offset, native_offset);
2812                                         }
2813                                 }
2814                         } else if (subtype == TYPE_SAMPLE_USYM) {
2815                                 /* un unmanaged symbol description */
2816                                 uintptr_t addr = ptr_base + decode_sleb128 (p + 1, &p);
2817                                 uintptr_t size = decode_uleb128 (p, &p);
2818                                 char *name;
2819                                 name = pstrdup ((char*)p);
2820                                 add_unmanaged_symbol (addr, name, size);
2821                                 if (debug)
2822                                         fprintf (outfile, "unmanaged symbol %s at %p\n", name, (void*)addr);
2823                                 while (*p) p++;
2824                                 p++;
2825                         } else if (subtype == TYPE_SAMPLE_UBIN) {
2826                                 /* un unmanaged binary loaded in memory */
2827                                 uint64_t tdiff = decode_uleb128 (p + 1, &p);
2828                                 uintptr_t addr = decode_sleb128 (p, &p);
2829                                 uint64_t offset G_GNUC_UNUSED = decode_uleb128 (p, &p);
2830                                 uintptr_t size = decode_uleb128 (p, &p);
2831                                 char *name;
2832                                 LOG_TIME (time_base, tdiff);
2833                                 time_base += tdiff;
2834                                 name = pstrdup ((char*)p);
2835                                 add_unmanaged_binary (addr, name, size);
2836                                 if (debug)
2837                                         fprintf (outfile, "unmanaged binary %s at %p\n", name, (void*)addr);
2838                                 while (*p) p++;
2839                                 p++;
2840                         } else if (subtype == TYPE_SAMPLE_COUNTERS_DESC) {
2841                                 uint64_t i, len = decode_uleb128 (p + 1, &p);
2842                                 for (i = 0; i < len; i++) {
2843                                         uint64_t type, unit, variance, index;
2844                                         uint64_t section = decode_uleb128 (p, &p);
2845                                         char *section_str, *name;
2846                                         if (section != MONO_COUNTER_PERFCOUNTERS) {
2847                                                 section_str = (char*) section_name (section);
2848                                         } else {
2849                                                 section_str = pstrdup ((char*)p);
2850                                                 while (*p++);
2851                                         }
2852                                         name = pstrdup ((char*)p);
2853                                         while (*p++);
2854                                         type = decode_uleb128 (p, &p);
2855                                         unit = decode_uleb128 (p, &p);
2856                                         variance = decode_uleb128 (p, &p);
2857                                         index = decode_uleb128 (p, &p);
2858                                         add_counter (section_str, name, (int)type, (int)unit, (int)variance, (int)index);
2859                                 }
2860                         } else if (subtype == TYPE_SAMPLE_COUNTERS) {
2861                                 int i;
2862                                 CounterValue *value, *previous = NULL;
2863                                 CounterList *list;
2864                                 uint64_t timestamp = decode_uleb128 (p + 1, &p);
2865                                 uint64_t time_between = timestamp / 1000 * 1000 * 1000 * 1000 + startup_time;
2866                                 while (1) {
2867                                         uint64_t type, index = decode_uleb128 (p, &p);
2868                                         if (index == 0)
2869                                                 break;
2870
2871                                         for (list = counters; list; list = list->next) {
2872                                                 if (list->counter->index == (int)index) {
2873                                                         previous = list->counter->values_last;
2874                                                         break;
2875                                                 }
2876                                         }
2877
2878                                         type = decode_uleb128 (p, &p);
2879
2880                                         value = (CounterValue *)calloc (1, sizeof (CounterValue));
2881                                         value->timestamp = timestamp;
2882
2883                                         switch (type) {
2884                                         case MONO_COUNTER_INT:
2885 #if SIZEOF_VOID_P == 4
2886                                         case MONO_COUNTER_WORD:
2887 #endif
2888                                                 value->buffer = (unsigned char *)malloc (sizeof (int32_t));
2889                                                 *(int32_t*)value->buffer = (int32_t)decode_sleb128 (p, &p) + (previous ? (*(int32_t*)previous->buffer) : 0);
2890                                                 break;
2891                                         case MONO_COUNTER_UINT:
2892                                                 value->buffer = (unsigned char *)malloc (sizeof (uint32_t));
2893                                                 *(uint32_t*)value->buffer = (uint32_t)decode_uleb128 (p, &p) + (previous ? (*(uint32_t*)previous->buffer) : 0);
2894                                                 break;
2895                                         case MONO_COUNTER_LONG:
2896 #if SIZEOF_VOID_P == 8
2897                                         case MONO_COUNTER_WORD:
2898 #endif
2899                                         case MONO_COUNTER_TIME_INTERVAL:
2900                                                 value->buffer = (unsigned char *)malloc (sizeof (int64_t));
2901                                                 *(int64_t*)value->buffer = (int64_t)decode_sleb128 (p, &p) + (previous ? (*(int64_t*)previous->buffer) : 0);
2902                                                 break;
2903                                         case MONO_COUNTER_ULONG:
2904                                                 value->buffer = (unsigned char *)malloc (sizeof (uint64_t));
2905                                                 *(uint64_t*)value->buffer = (uint64_t)decode_uleb128 (p, &p) + (previous ? (*(uint64_t*)previous->buffer) : 0);
2906                                                 break;
2907                                         case MONO_COUNTER_DOUBLE:
2908                                                 value->buffer = (unsigned char *)malloc (sizeof (double));
2909 #if TARGET_BYTE_ORDER == G_LITTLE_ENDIAN
2910                                                 for (i = 0; i < sizeof (double); i++)
2911 #else
2912                                                 for (i = sizeof (double) - 1; i >= 0; i--)
2913 #endif
2914                                                         value->buffer[i] = *p++;
2915                                                 break;
2916                                         case MONO_COUNTER_STRING:
2917                                                 if (*p++ == 0) {
2918                                                         value->buffer = NULL;
2919                                                 } else {
2920                                                         value->buffer = (unsigned char*) pstrdup ((char*)p);
2921                                                         while (*p++);
2922                                                 }
2923                                                 break;
2924                                         }
2925                                         if (time_between >= time_from && time_between <= time_to)
2926                                                 add_counter_value (index, value);
2927                                 }
2928                         } else {
2929                                 return 0;
2930                         }
2931                         break;
2932                 }
2933                 case TYPE_COVERAGE:{
2934                         int subtype = *p & 0xf0;
2935                         switch (subtype) {
2936                         case TYPE_COVERAGE_METHOD: {
2937                                 CoverageMethod *method = g_new0 (CoverageMethod, 1);
2938                                 const char *assembly, *klass, *name, *sig, *filename;
2939                                 int token, n_offsets, method_id;
2940
2941                                 p++;
2942                                 assembly = (const char *)p; while (*p) p++; p++;
2943                                 klass = (const char *)p; while (*p) p++; p++;
2944                                 name = (const char *)p; while (*p) p++; p++;
2945                                 sig = (const char *)p; while (*p) p++; p++;
2946                                 filename = (const char *)p; while (*p) p++; p++;
2947
2948                                 token = decode_uleb128 (p, &p);
2949                                 method_id = decode_uleb128 (p, &p);
2950                                 n_offsets = decode_uleb128 (p, &p);
2951
2952                                 method->assembly_name = g_strdup (assembly);
2953                                 method->class_name = g_strdup (klass);
2954                                 method->method_name = g_strdup (name);
2955                                 method->method_signature = g_strdup (sig);
2956                                 method->filename = g_strdup (filename);
2957                                 method->token = token;
2958                                 method->n_statements = n_offsets;
2959                                 method->coverage = g_ptr_array_new ();
2960                                 method->method_id = method_id;
2961
2962                                 coverage_add_method (method);
2963
2964                                 break;
2965                         }
2966                         case TYPE_COVERAGE_STATEMENT: {
2967                                 CoverageCoverage *coverage = g_new0 (CoverageCoverage, 1);
2968                                 int offset, count, line, column, method_id;
2969
2970                                 p++;
2971                                 method_id = decode_uleb128 (p, &p);
2972                                 offset = decode_uleb128 (p, &p);
2973                                 count = decode_uleb128 (p, &p);
2974                                 line = decode_uleb128 (p, &p);
2975                                 column = decode_uleb128 (p, &p);
2976
2977                                 coverage->method_id = method_id;
2978                                 coverage->offset = offset;
2979                                 coverage->count = count;
2980                                 coverage->line = line;
2981                                 coverage->column = column;
2982
2983                                 coverage_add_coverage (coverage);
2984                                 break;
2985                         }
2986                         case TYPE_COVERAGE_ASSEMBLY: {
2987                                 CoverageAssembly *assembly = g_new0 (CoverageAssembly, 1);
2988                                 char *name, *guid, *filename;
2989                                 int number_of_methods, fully_covered, partially_covered;
2990                                 p++;
2991
2992                                 name = (char *)p; while (*p) p++; p++;
2993                                 guid = (char *)p; while (*p) p++; p++;
2994                                 filename = (char *)p; while (*p) p++; p++;
2995                                 number_of_methods = decode_uleb128 (p, &p);
2996                                 fully_covered = decode_uleb128 (p, &p);
2997                                 partially_covered = decode_uleb128 (p, &p);
2998
2999                                 assembly->name = g_strdup (name);
3000                                 assembly->guid = g_strdup (guid);
3001                                 assembly->filename = g_strdup (filename);
3002                                 assembly->number_of_methods = number_of_methods;
3003                                 assembly->fully_covered = fully_covered;
3004                                 assembly->partially_covered = partially_covered;
3005
3006                                 coverage_add_assembly (assembly);
3007                                 break;
3008                         }
3009                         case TYPE_COVERAGE_CLASS: {
3010                                 CoverageClass *klass = g_new0 (CoverageClass, 1);
3011                                 char *assembly_name, *class_name;
3012                                 int number_of_methods, fully_covered, partially_covered;
3013                                 p++;
3014
3015                                 assembly_name = (char *)p; while (*p) p++; p++;
3016                                 class_name = (char *)p; while (*p) p++; p++;
3017                                 number_of_methods = decode_uleb128 (p, &p);
3018                                 fully_covered = decode_uleb128 (p, &p);
3019                                 partially_covered = decode_uleb128 (p, &p);
3020
3021                                 klass->assembly_name = g_strdup (assembly_name);
3022                                 klass->class_name = g_strdup (class_name);
3023                                 klass->number_of_methods = number_of_methods;
3024                                 klass->fully_covered = fully_covered;
3025                                 klass->partially_covered = partially_covered;
3026
3027                                 coverage_add_class (klass);
3028                                 break;
3029                         }
3030
3031                         default:
3032                                 break;
3033                         }
3034                         break;
3035                 }
3036                 default:
3037                         fprintf (outfile, "unhandled profiler event: 0x%x at file offset: %llu + %lld (len: %d\n)\n", *p, (unsigned long long) file_offset, (long long) (p - ctx->buf), len);
3038                         exit (1);
3039                 }
3040                 record_event_stats (event, p - start);
3041         }
3042         thread->last_time = time_base;
3043         for (i = 0; i < thread->stack_id; ++i)
3044                 thread->stack [i]->recurse_count = 0;
3045         return 1;
3046 }
3047
3048 static ProfContext*
3049 load_file (char *name)
3050 {
3051         unsigned char *p;
3052         ProfContext *ctx = (ProfContext *)calloc (sizeof (ProfContext), 1);
3053         if (strcmp (name, "-") == 0)
3054                 ctx->file = stdin;
3055         else
3056                 ctx->file = fopen (name, "rb");
3057         if (!ctx->file) {
3058                 printf ("Cannot open file: %s\n", name);
3059                 exit (1);
3060         }
3061 #if defined (HAVE_SYS_ZLIB)
3062         if (ctx->file != stdin)
3063                 ctx->gzfile = gzdopen (fileno (ctx->file), "rb");
3064 #endif
3065         if (!load_data (ctx, 32))
3066                 return NULL;
3067         p = ctx->buf;
3068         if (read_int32 (p) != LOG_HEADER_ID || p [6] > LOG_DATA_VERSION)
3069                 return NULL;
3070         ctx->version_major = p [4];
3071         ctx->version_minor = p [5];
3072         ctx->data_version = p [6];
3073         /* reading 64 bit files on 32 bit systems not supported yet */
3074         if (p [7] > sizeof (void*))
3075                 return NULL;
3076         if (read_int32 (p + 20)) /* flags must be 0 */
3077                 return NULL;
3078         ctx->startup_time = read_int64 (p + 8);
3079         ctx->timer_overhead = read_int32 (p + 16);
3080         ctx->pid = read_int32 (p + 24);
3081         ctx->port = read_int16 (p + 28);
3082         return ctx;
3083 }
3084
3085 enum {
3086         ALLOC_SORT_BYTES,
3087         ALLOC_SORT_COUNT
3088 };
3089 static int alloc_sort_mode = ALLOC_SORT_BYTES;
3090
3091 static int
3092 compare_class (const void *a, const void *b)
3093 {
3094         ClassDesc *const *A = (ClassDesc *const *)a;
3095         ClassDesc *const *B = (ClassDesc *const *)b;
3096         uint64_t vala, valb;
3097         if (alloc_sort_mode == ALLOC_SORT_BYTES) {
3098                 vala = (*A)->alloc_size;
3099                 valb = (*B)->alloc_size;
3100         } else {
3101                 vala = (*A)->allocs;
3102                 valb = (*B)->allocs;
3103         }
3104         if (valb == vala)
3105                 return 0;
3106         if (valb < vala)
3107                 return -1;
3108         return 1;
3109 }
3110
3111 static void
3112 dump_header (ProfContext *ctx)
3113 {
3114         time_t st = ctx->startup_time / 1000;
3115         char *t = ctime (&st);
3116         fprintf (outfile, "\nMono log profiler data\n");
3117         fprintf (outfile, "\tProfiler version: %d.%d\n", ctx->version_major, ctx->version_minor);
3118         fprintf (outfile, "\tData version: %d\n", ctx->data_version);
3119         fprintf (outfile, "\tMean timer overhead: %d nanoseconds\n", ctx->timer_overhead);
3120         fprintf (outfile, "\tProgram startup: %s", t);
3121         if (ctx->pid)
3122                 fprintf (outfile, "\tProgram ID: %d\n", ctx->pid);
3123         if (ctx->port)
3124                 fprintf (outfile, "\tServer listening on: %d\n", ctx->port);
3125 }
3126
3127 static void
3128 dump_traces (TraceDesc *traces, const char *desc)
3129 {
3130         int j;
3131         if (!show_traces)
3132                 return;
3133         if (!traces->count)
3134                 return;
3135         sort_context_array (traces);
3136         for (j = 0; j < traces->count; ++j) {
3137                 int k;
3138                 BackTrace *bt;
3139                 bt = traces->traces [j].bt;
3140                 if (!bt->count)
3141                         continue;
3142                 fprintf (outfile, "\t%llu %s from:\n", (unsigned long long) traces->traces [j].count, desc);
3143                 for (k = 0; k < bt->count; ++k)
3144                         fprintf (outfile, "\t\t%s\n", bt->methods [k]->name);
3145         }
3146 }
3147
3148 static void
3149 dump_threads (ProfContext *ctx)
3150 {
3151         ThreadContext *thread;
3152         fprintf (outfile, "\nThread summary\n");
3153         for (thread = ctx->threads; thread; thread = thread->next) {
3154                 fprintf (outfile, "\tThread: %p, name: \"%s\"\n", (void*)thread->thread_id, thread->name? thread->name: "");
3155         }
3156 }
3157
3158 static void
3159 dump_domains (ProfContext *ctx)
3160 {
3161         fprintf (outfile, "\nDomain summary\n");
3162
3163         for (DomainContext *domain = ctx->domains; domain; domain = domain->next)
3164                 fprintf (outfile, "\tDomain: %p, friendly name: \"%s\"\n", (void *) domain->domain_id, domain->friendly_name);
3165 }
3166
3167 static void
3168 dump_remctxs (ProfContext *ctx)
3169 {
3170         fprintf (outfile, "\nContext summary\n");
3171
3172         for (RemCtxContext *remctx = ctx->remctxs; remctx; remctx = remctx->next)
3173                 fprintf (outfile, "\tContext: %p, domain: %p\n", (void *) remctx->remctx_id, (void *) remctx->domain_id);
3174 }
3175
3176 static void
3177 dump_exceptions (void)
3178 {
3179         int i;
3180         fprintf (outfile, "\nException summary\n");
3181         fprintf (outfile, "\tThrows: %llu\n", (unsigned long long) throw_count);
3182         dump_traces (&exc_traces, "throws");
3183         for (i = 0; i <= MONO_EXCEPTION_CLAUSE_FAULT; ++i) {
3184                 if (!clause_summary [i])
3185                         continue;
3186                 fprintf (outfile, "\tExecuted %s clauses: %llu\n", clause_name (i), (unsigned long long) clause_summary [i]);
3187         }
3188 }
3189
3190 static int
3191 compare_monitor (const void *a, const void *b)
3192 {
3193         MonitorDesc *const *A = (MonitorDesc *const *)a;
3194         MonitorDesc *const *B = (MonitorDesc *const *)b;
3195         if ((*B)->wait_time == (*A)->wait_time)
3196                 return 0;
3197         if ((*B)->wait_time < (*A)->wait_time)
3198                 return -1;
3199         return 1;
3200 }
3201
3202 static void
3203 dump_monitors (void)
3204 {
3205         MonitorDesc **monitors;
3206         int i, j;
3207         if (!num_monitors)
3208                 return;
3209         monitors = (MonitorDesc **)malloc (sizeof (void*) * num_monitors);
3210         for (i = 0, j = 0; i < SMALL_HASH_SIZE; ++i) {
3211                 MonitorDesc *mdesc = monitor_hash [i];
3212                 while (mdesc) {
3213                         monitors [j++] = mdesc;
3214                         mdesc = mdesc->next;
3215                 }
3216         }
3217         qsort (monitors, num_monitors, sizeof (void*), compare_monitor);
3218         fprintf (outfile, "\nMonitor lock summary\n");
3219         for (i = 0; i < num_monitors; ++i) {
3220                 MonitorDesc *mdesc = monitors [i];
3221                 fprintf (outfile, "\tLock object %p: %d contentions\n", (void*)mdesc->objid, (int)mdesc->contentions);
3222                 fprintf (outfile, "\t\t%.6f secs total wait time, %.6f max, %.6f average\n",
3223                         mdesc->wait_time/1000000000.0, mdesc->max_wait_time/1000000000.0, mdesc->wait_time/1000000000.0/mdesc->contentions);
3224                 dump_traces (&mdesc->traces, "contentions");
3225         }
3226         fprintf (outfile, "\tLock contentions: %llu\n", (unsigned long long) monitor_contention);
3227         fprintf (outfile, "\tLock acquired: %llu\n", (unsigned long long) monitor_acquired);
3228         fprintf (outfile, "\tLock failures: %llu\n", (unsigned long long) monitor_failed);
3229 }
3230
3231 static void
3232 dump_gcs (void)
3233 {
3234         int i;
3235         fprintf (outfile, "\nGC summary\n");
3236         fprintf (outfile, "\tGC resizes: %d\n", gc_resizes);
3237         fprintf (outfile, "\tMax heap size: %llu\n", (unsigned long long) max_heap_size);
3238         fprintf (outfile, "\tObject moves: %llu\n", (unsigned long long) gc_object_moves);
3239         for (i = 0; i < 3; ++i) {
3240                 if (!gc_info [i].count)
3241                         continue;
3242                 fprintf (outfile, "\tGen%d collections: %d, max time: %lluus, total time: %lluus, average: %lluus\n",
3243                         i, gc_info [i].count,
3244                         (unsigned long long) (gc_info [i].max_time / 1000),
3245                         (unsigned long long) (gc_info [i].total_time / 1000),
3246                         (unsigned long long) (gc_info [i].total_time / gc_info [i].count / 1000));
3247         }
3248         for (i = 0; i < 3; ++i) {
3249                 if (!handle_info [i].max_live)
3250                         continue;
3251                 fprintf (outfile, "\tGC handles %s: created: %llu, destroyed: %llu, max: %llu\n",
3252                         get_handle_name (i),
3253                         (unsigned long long) (handle_info [i].created),
3254                         (unsigned long long) (handle_info [i].destroyed),
3255                         (unsigned long long) (handle_info [i].max_live));
3256                 dump_traces (&handle_info [i].traces, "created");
3257                 dump_traces (&handle_info [i].destroy_traces, "destroyed");
3258         }
3259 }
3260
3261 static void
3262 dump_jit (void)
3263 {
3264         int i;
3265         int code_size = 0;
3266         int compiled_methods = 0;
3267         MethodDesc* m;
3268         fprintf (outfile, "\nJIT summary\n");
3269         for (i = 0; i < HASH_SIZE; ++i) {
3270                 m = method_hash [i];
3271                 for (m = method_hash [i]; m; m = m->next) {
3272                         if (!m->code || m->ignore_jit)
3273                                 continue;
3274                         compiled_methods++;
3275                         code_size += m->len;
3276                 }
3277         }
3278         fprintf (outfile, "\tCompiled methods: %d\n", compiled_methods);
3279         fprintf (outfile, "\tGenerated code size: %d\n", code_size);
3280         fprintf (outfile, "\tJIT helpers: %d\n", num_jit_helpers);
3281         fprintf (outfile, "\tJIT helpers code size: %d\n", jit_helpers_code_size);
3282 }
3283
3284 static void
3285 dump_allocations (void)
3286 {
3287         int i, c;
3288         intptr_t allocs = 0;
3289         uint64_t size = 0;
3290         int header_done = 0;
3291         ClassDesc **classes = (ClassDesc **)malloc (num_classes * sizeof (void*));
3292         ClassDesc *cd;
3293         c = 0;
3294         for (i = 0; i < HASH_SIZE; ++i) {
3295                 cd = class_hash [i];
3296                 while (cd) {
3297                         classes [c++] = cd;
3298                         cd = cd->next;
3299                 }
3300         }
3301         qsort (classes, num_classes, sizeof (void*), compare_class);
3302         for (i = 0; i < num_classes; ++i) {
3303                 cd = classes [i];
3304                 if (!cd->allocs)
3305                         continue;
3306                 allocs += cd->allocs;
3307                 size += cd->alloc_size;
3308                 if (!header_done++) {
3309                         fprintf (outfile, "\nAllocation summary\n");
3310                         fprintf (outfile, "%10s %10s %8s Type name\n", "Bytes", "Count", "Average");
3311                 }
3312                 fprintf (outfile, "%10llu %10zd %8llu %s\n",
3313                         (unsigned long long) (cd->alloc_size),
3314                         cd->allocs,
3315                         (unsigned long long) (cd->alloc_size / cd->allocs),
3316                         cd->name);
3317                 dump_traces (&cd->traces, "bytes");
3318         }
3319         if (allocs)
3320                 fprintf (outfile, "Total memory allocated: %llu bytes in %zd objects\n", (unsigned long long) size, allocs);
3321 }
3322
3323 enum {
3324         METHOD_SORT_TOTAL,
3325         METHOD_SORT_SELF,
3326         METHOD_SORT_CALLS
3327 };
3328
3329 static int method_sort_mode = METHOD_SORT_TOTAL;
3330
3331 static int
3332 compare_method (const void *a, const void *b)
3333 {
3334         MethodDesc *const *A = (MethodDesc *const *)a;
3335         MethodDesc *const *B = (MethodDesc *const *)b;
3336         uint64_t vala, valb;
3337         if (method_sort_mode == METHOD_SORT_SELF) {
3338                 vala = (*A)->self_time;
3339                 valb = (*B)->self_time;
3340         } else if (method_sort_mode == METHOD_SORT_CALLS) {
3341                 vala = (*A)->calls;
3342                 valb = (*B)->calls;
3343         } else {
3344                 vala = (*A)->total_time;
3345                 valb = (*B)->total_time;
3346         }
3347         if (vala == valb)
3348                 return 0;
3349         if (valb < vala)
3350                 return -1;
3351         return 1;
3352 }
3353
3354 static void
3355 dump_metadata (void)
3356 {
3357         fprintf (outfile, "\nMetadata summary\n");
3358         fprintf (outfile, "\tLoaded images: %d\n", num_images);
3359         if (verbose) {
3360                 ImageDesc *image;
3361                 int i;
3362                 for (i = 0; i < SMALL_HASH_SIZE; ++i) {
3363                         image = image_hash [i];
3364                         while (image) {
3365                                 fprintf (outfile, "\t\t%s\n", image->filename);
3366                                 image = image->next;
3367                         }
3368                 }
3369         }
3370         fprintf (outfile, "\tLoaded assemblies: %d\n", num_assemblies);
3371         if (verbose) {
3372                 AssemblyDesc *assembly;
3373                 int i;
3374                 for (i = 0; i < SMALL_HASH_SIZE; ++i) {
3375                         assembly = assembly_hash [i];
3376                         while (assembly) {
3377                                 fprintf (outfile, "\t\t%s\n", assembly->asmname);
3378                                 assembly = assembly->next;
3379                         }
3380                 }
3381         }
3382 }
3383
3384 static void
3385 dump_methods (void)
3386 {
3387         int i, c;
3388         uint64_t calls = 0;
3389         int header_done = 0;
3390         MethodDesc **methods = (MethodDesc **)malloc (num_methods * sizeof (void*));
3391         MethodDesc *cd;
3392         c = 0;
3393         for (i = 0; i < HASH_SIZE; ++i) {
3394                 cd = method_hash [i];
3395                 while (cd) {
3396                         cd->total_time = cd->self_time + cd->callee_time;
3397                         methods [c++] = cd;
3398                         cd = cd->next;
3399                 }
3400         }
3401         qsort (methods, num_methods, sizeof (void*), compare_method);
3402         for (i = 0; i < num_methods; ++i) {
3403                 uint64_t msecs;
3404                 uint64_t smsecs;
3405                 cd = methods [i];
3406                 if (!cd->calls)
3407                         continue;
3408                 calls += cd->calls;
3409                 msecs = cd->total_time / 1000000;
3410                 smsecs = (cd->total_time - cd->callee_time) / 1000000;
3411                 if (!msecs && !verbose)
3412                         continue;
3413                 if (!header_done++) {
3414                         fprintf (outfile, "\nMethod call summary\n");
3415                         fprintf (outfile, "%8s %8s %10s Method name\n", "Total(ms)", "Self(ms)", "Calls");
3416                 }
3417                 fprintf (outfile, "%8llu %8llu %10llu %s\n",
3418                         (unsigned long long) (msecs),
3419                         (unsigned long long) (smsecs),
3420                         (unsigned long long) (cd->calls),
3421                         cd->name);
3422                 dump_traces (&cd->traces, "calls");
3423         }
3424         if (calls)
3425                 fprintf (outfile, "Total calls: %llu\n", (unsigned long long) calls);
3426 }
3427
3428 static int
3429 compare_heap_class (const void *a, const void *b)
3430 {
3431         HeapClassDesc *const *A = (HeapClassDesc *const *)a;
3432         HeapClassDesc *const *B = (HeapClassDesc *const *)b;
3433         uint64_t vala, valb;
3434         if (alloc_sort_mode == ALLOC_SORT_BYTES) {
3435                 vala = (*A)->total_size;
3436                 valb = (*B)->total_size;
3437         } else {
3438                 vala = (*A)->count;
3439                 valb = (*B)->count;
3440         }
3441         if (valb == vala)
3442                 return 0;
3443         if (valb < vala)
3444                 return -1;
3445         return 1;
3446 }
3447
3448 static int
3449 compare_rev_class (const void *a, const void *b)
3450 {
3451         const HeapClassRevRef *A = (const HeapClassRevRef *)a;
3452         const HeapClassRevRef *B = (const HeapClassRevRef *)b;
3453         if (B->count == A->count)
3454                 return 0;
3455         if (B->count < A->count)
3456                 return -1;
3457         return 1;
3458 }
3459
3460 static void
3461 dump_rev_claases (HeapClassRevRef *revs, int count)
3462 {
3463         int j;
3464         if (!show_traces)
3465                 return;
3466         if (!count)
3467                 return;
3468         for (j = 0; j < count; ++j) {
3469                 HeapClassDesc *cd = revs [j].klass;
3470                 fprintf (outfile, "\t\t%llu references from: %s\n",
3471                         (unsigned long long) (revs [j].count),
3472                         cd->klass->name);
3473         }
3474 }
3475
3476 static void
3477 heap_shot_summary (HeapShot *hs, int hs_num, HeapShot *last_hs)
3478 {
3479         uint64_t size = 0;
3480         uint64_t count = 0;
3481         int ccount = 0;
3482         int i;
3483         HeapClassDesc *cd;
3484         HeapClassDesc **sorted;
3485         sorted = (HeapClassDesc **)malloc (sizeof (void*) * hs->class_count);
3486         for (i = 0; i < hs->hash_size; ++i) {
3487                 cd = hs->class_hash [i];
3488                 if (!cd)
3489                         continue;
3490                 count += cd->count;
3491                 size += cd->total_size;
3492                 sorted [ccount++] = cd;
3493         }
3494         hs->sorted = sorted;
3495         qsort (sorted, ccount, sizeof (void*), compare_heap_class);
3496         fprintf (outfile, "\n\tHeap shot %d at %.3f secs: size: %llu, object count: %llu, class count: %d, roots: %zd\n",
3497                 hs_num,
3498                 (hs->timestamp - startup_time)/1000000000.0,
3499                 (unsigned long long) (size),
3500                 (unsigned long long) (count),
3501                 ccount, hs->num_roots);
3502         if (!verbose && ccount > 30)
3503                 ccount = 30;
3504         fprintf (outfile, "\t%10s %10s %8s Class name\n", "Bytes", "Count", "Average");
3505         for (i = 0; i < ccount; ++i) {
3506                 HeapClassRevRef *rev_sorted;
3507                 int j, k;
3508                 HeapClassDesc *ocd = NULL;
3509                 cd = sorted [i];
3510                 if (last_hs)
3511                         ocd = heap_class_lookup (last_hs, cd->klass);
3512                 fprintf (outfile, "\t%10llu %10llu %8llu %s",
3513                         (unsigned long long) (cd->total_size),
3514                         (unsigned long long) (cd->count),
3515                         (unsigned long long) (cd->total_size / cd->count),
3516                         cd->klass->name);
3517                 if (ocd) {
3518                         int64_t bdiff = cd->total_size - ocd->total_size;
3519                         int64_t cdiff = cd->count - ocd->count;
3520                         fprintf (outfile, " (bytes: %+lld, count: %+lld)\n", (long long) bdiff, (long long) cdiff);
3521                 } else {
3522                         fprintf (outfile, "\n");
3523                 }
3524                 if (!collect_traces)
3525                         continue;
3526                 rev_sorted = (HeapClassRevRef *)malloc (cd->rev_count * sizeof (HeapClassRevRef));
3527                 k = 0;
3528                 for (j = 0; j < cd->rev_hash_size; ++j) {
3529                         if (cd->rev_hash [j].klass)
3530                                 rev_sorted [k++] = cd->rev_hash [j];
3531                 }
3532                 assert (cd->rev_count == k);
3533                 qsort (rev_sorted, cd->rev_count, sizeof (HeapClassRevRef), compare_rev_class);
3534                 if (cd->root_references)
3535                         fprintf (outfile, "\t\t%zd root references (%zd pinning)\n", cd->root_references, cd->pinned_references);
3536                 dump_rev_claases (rev_sorted, cd->rev_count);
3537                 free (rev_sorted);
3538         }
3539         free (sorted);
3540 }
3541
3542 static int
3543 compare_heap_shots (const void *a, const void *b)
3544 {
3545         HeapShot *const *A = (HeapShot *const *)a;
3546         HeapShot *const *B = (HeapShot *const *)b;
3547         if ((*B)->timestamp == (*A)->timestamp)
3548                 return 0;
3549         if ((*B)->timestamp > (*A)->timestamp)
3550                 return -1;
3551         return 1;
3552 }
3553
3554 static void
3555 dump_heap_shots (void)
3556 {
3557         HeapShot **hs_sorted;
3558         HeapShot *hs;
3559         HeapShot *last_hs = NULL;
3560         int i;
3561         if (!heap_shots)
3562                 return;
3563         hs_sorted = (HeapShot **)malloc (num_heap_shots * sizeof (void*));
3564         fprintf (outfile, "\nHeap shot summary\n");
3565         i = 0;
3566         for (hs = heap_shots; hs; hs = hs->next)
3567                 hs_sorted [i++] = hs;
3568         qsort (hs_sorted, num_heap_shots, sizeof (void*), compare_heap_shots);
3569         for (i = 0; i < num_heap_shots; ++i) {
3570                 hs = hs_sorted [i];
3571                 heap_shot_summary (hs, i, last_hs);
3572                 last_hs = hs;
3573         }
3574 }
3575
3576 /* This is a very basic escape function that escapes < > and &
3577    Ideally we'd use g_markup_escape_string but that function isn't
3578          available in Mono's eglib. This was written without looking at the
3579          source of that function in glib. */
3580 static char *
3581 escape_string_for_xml (const char *string)
3582 {
3583         GString *string_builder = g_string_new (NULL);
3584         const char *start, *p;
3585
3586         start = p = string;
3587         while (*p) {
3588                 while (*p && *p != '&' && *p != '<' && *p != '>')
3589                         p++;
3590
3591                 g_string_append_len (string_builder, start, p - start);
3592
3593                 if (*p == '\0')
3594                         break;
3595
3596                 switch (*p) {
3597                 case '<':
3598                         g_string_append (string_builder, "&lt;");
3599                         break;
3600
3601                 case '>':
3602                         g_string_append (string_builder, "&gt;");
3603                         break;
3604
3605                 case '&':
3606                         g_string_append (string_builder, "&amp;");
3607                         break;
3608
3609                 default:
3610                         break;
3611                 }
3612
3613                 p++;
3614                 start = p;
3615         }
3616
3617         return g_string_free (string_builder, FALSE);
3618 }
3619
3620 static int
3621 sort_assemblies (gconstpointer a, gconstpointer b)
3622 {
3623         CoverageAssembly *assembly_a = *(CoverageAssembly **)a;
3624         CoverageAssembly *assembly_b = *(CoverageAssembly **)b;
3625
3626         if (assembly_a->name == NULL && assembly_b->name == NULL)
3627                 return 0;
3628         else if (assembly_a->name == NULL)
3629                 return -1;
3630         else if (assembly_b->name == NULL)
3631                 return 1;
3632
3633         return strcmp (assembly_a->name, assembly_b->name);
3634 }
3635
3636 static void
3637 dump_coverage (void)
3638 {
3639         if (!coverage_methods && !coverage_assemblies)
3640                 return;
3641
3642         gather_coverage_statements ();
3643         fprintf (outfile, "\nCoverage Summary:\n");
3644
3645         if (coverage_outfile) {
3646                 fprintf (coverage_outfile, "<?xml version=\"1.0\"?>\n");
3647                 fprintf (coverage_outfile, "<coverage version=\"0.3\">\n");
3648         }
3649
3650         g_ptr_array_sort (coverage_assemblies, sort_assemblies);
3651
3652         for (guint i = 0; i < coverage_assemblies->len; i++) {
3653                 CoverageAssembly *assembly = (CoverageAssembly *)coverage_assemblies->pdata[i];
3654                 GPtrArray *classes;
3655
3656                 if (assembly->number_of_methods != 0) {
3657                         int percentage = ((assembly->fully_covered + assembly->partially_covered) * 100) / assembly->number_of_methods;
3658                         fprintf (outfile, "\t%s (%s) %d%% covered (%d methods - %d covered)\n", assembly->name, assembly->filename, percentage, assembly->number_of_methods, assembly->fully_covered);
3659                 } else
3660                         fprintf (outfile, "\t%s (%s) ?%% covered (%d methods - %d covered)\n", assembly->name, assembly->filename, assembly->number_of_methods, assembly->fully_covered);
3661
3662                 if (coverage_outfile) {
3663                         char *escaped_name, *escaped_filename;
3664                         escaped_name = escape_string_for_xml (assembly->name);
3665                         escaped_filename = escape_string_for_xml (assembly->filename);
3666
3667                         fprintf (coverage_outfile, "\t<assembly name=\"%s\" guid=\"%s\" filename=\"%s\" method-count=\"%d\" full=\"%d\" partial=\"%d\"/>\n", escaped_name, assembly->guid, escaped_filename, assembly->number_of_methods, assembly->fully_covered, assembly->partially_covered);
3668
3669                         g_free (escaped_name);
3670                         g_free (escaped_filename);
3671                 }
3672
3673                 classes = (GPtrArray *)g_hash_table_lookup (coverage_assembly_classes, assembly->name);
3674                 if (classes) {
3675                         for (guint j = 0; j < classes->len; j++) {
3676                                 CoverageClass *klass = (CoverageClass *)classes->pdata [j];
3677
3678                                 if (klass->number_of_methods > 0) {
3679                                         int percentage = ((klass->fully_covered + klass->partially_covered) * 100) / klass->number_of_methods;
3680                                         fprintf (outfile, "\t\t%s %d%% covered (%d methods - %d covered)\n", klass->class_name, percentage, klass->number_of_methods, klass->fully_covered);
3681                                 } else
3682                                         fprintf (outfile, "\t\t%s ?%% covered (%d methods - %d covered)\n", klass->class_name, klass->number_of_methods, klass->fully_covered);
3683
3684                                 if (coverage_outfile) {
3685                                         char *escaped_name;
3686                                         escaped_name = escape_string_for_xml (klass->class_name);
3687
3688                                         fprintf (coverage_outfile, "\t\t<class name=\"%s\" method-count=\"%d\" full=\"%d\" partial=\"%d\"/>\n", escaped_name, klass->number_of_methods, klass->fully_covered, klass->partially_covered);
3689                                         g_free (escaped_name);
3690                                 }
3691                         }
3692                 }
3693         }
3694
3695         for (guint i = 0; i < coverage_methods->len; i++) {
3696                 CoverageMethod *method = (CoverageMethod *)coverage_methods->pdata [i];
3697
3698                 if (coverage_outfile) {
3699                         char *escaped_assembly, *escaped_class, *escaped_method, *escaped_sig, *escaped_filename;
3700
3701                         escaped_assembly = escape_string_for_xml (method->assembly_name);
3702                         escaped_class = escape_string_for_xml (method->class_name);
3703                         escaped_method = escape_string_for_xml (method->method_name);
3704                         escaped_sig = escape_string_for_xml (method->method_signature);
3705                         escaped_filename = escape_string_for_xml (method->filename);
3706
3707                         fprintf (coverage_outfile, "\t<method assembly=\"%s\" class=\"%s\" name=\"%s (%s)\" filename=\"%s\" token=\"%d\">\n", escaped_assembly, escaped_class, escaped_method, escaped_sig, escaped_filename, method->token);
3708
3709                         g_free (escaped_assembly);
3710                         g_free (escaped_class);
3711                         g_free (escaped_method);
3712                         g_free (escaped_sig);
3713                         g_free (escaped_filename);
3714
3715                         for (guint j = 0; j < method->coverage->len; j++) {
3716                                 CoverageCoverage *coverage = (CoverageCoverage *)method->coverage->pdata [j];
3717                                 fprintf (coverage_outfile, "\t\t<statement offset=\"%d\" counter=\"%d\" line=\"%d\" column=\"%d\"/>\n", coverage->offset, coverage->count, coverage->line, coverage->column);
3718                         }
3719                         fprintf (coverage_outfile, "\t</method>\n");
3720                 }
3721         }
3722
3723         if (coverage_outfile) {
3724                 fprintf (coverage_outfile, "</coverage>\n");
3725                 fclose (coverage_outfile);
3726                 coverage_outfile = NULL;
3727         }
3728 }
3729
3730 #define DUMP_EVENT_STAT(EVENT,SUBTYPE) dump_event (#EVENT, #SUBTYPE, EVENT, SUBTYPE);
3731
3732 static void
3733 dump_event (const char *event_name, const char *subtype_name, int event, int subtype)
3734 {
3735         int idx = event | subtype;
3736         EventStat evt = stats [idx];
3737         if (!evt.count)
3738                 return;
3739
3740         fprintf (outfile, "\t%16s\t%26s\tcount %6d\tmin %3d\tmax %6d\tbytes %d\n", event_name, subtype_name, evt.count, evt.min_size, evt.max_size, evt.bytes);
3741 }
3742
3743 static void
3744 dump_stats (void)
3745 {
3746         fprintf (outfile, "\nMlpd statistics\n");
3747         fprintf (outfile, "\tBuffer count %d\toverhead %d (%d bytes per header)\n", buffer_count, buffer_count * BUFFER_HEADER_SIZE, BUFFER_HEADER_SIZE);
3748         fprintf (outfile, "\nEvent details:\n");
3749
3750         DUMP_EVENT_STAT (TYPE_ALLOC, TYPE_ALLOC_NO_BT);
3751         DUMP_EVENT_STAT (TYPE_ALLOC, TYPE_ALLOC_BT);
3752
3753         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_EVENT);
3754         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_RESIZE);
3755         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_MOVE);
3756         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_HANDLE_CREATED);
3757         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_HANDLE_DESTROYED);
3758         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_HANDLE_CREATED_BT);
3759         DUMP_EVENT_STAT (TYPE_GC, TYPE_GC_HANDLE_DESTROYED_BT);
3760
3761         DUMP_EVENT_STAT (TYPE_METADATA, TYPE_END_LOAD);
3762         DUMP_EVENT_STAT (TYPE_METADATA, TYPE_END_UNLOAD);
3763
3764         DUMP_EVENT_STAT (TYPE_METHOD, TYPE_LEAVE);
3765         DUMP_EVENT_STAT (TYPE_METHOD, TYPE_ENTER);
3766         DUMP_EVENT_STAT (TYPE_METHOD, TYPE_EXC_LEAVE);
3767         DUMP_EVENT_STAT (TYPE_METHOD, TYPE_JIT);
3768
3769         DUMP_EVENT_STAT (TYPE_EXCEPTION, TYPE_THROW);
3770         DUMP_EVENT_STAT (TYPE_EXCEPTION, TYPE_CLAUSE);
3771         DUMP_EVENT_STAT (TYPE_EXCEPTION, TYPE_EXCEPTION_BT);
3772
3773         DUMP_EVENT_STAT (TYPE_MONITOR, TYPE_MONITOR_NO_BT);
3774         DUMP_EVENT_STAT (TYPE_MONITOR, TYPE_MONITOR_BT);
3775
3776         DUMP_EVENT_STAT (TYPE_HEAP, TYPE_HEAP_START);
3777         DUMP_EVENT_STAT (TYPE_HEAP, TYPE_HEAP_END);
3778         DUMP_EVENT_STAT (TYPE_HEAP, TYPE_HEAP_OBJECT);
3779         DUMP_EVENT_STAT (TYPE_HEAP, TYPE_HEAP_ROOT);
3780
3781         DUMP_EVENT_STAT (TYPE_SAMPLE, TYPE_SAMPLE_HIT);
3782         DUMP_EVENT_STAT (TYPE_SAMPLE, TYPE_SAMPLE_USYM);
3783         DUMP_EVENT_STAT (TYPE_SAMPLE, TYPE_SAMPLE_UBIN);
3784         DUMP_EVENT_STAT (TYPE_SAMPLE, TYPE_SAMPLE_COUNTERS_DESC);
3785         DUMP_EVENT_STAT (TYPE_SAMPLE, TYPE_SAMPLE_COUNTERS);
3786
3787         DUMP_EVENT_STAT (TYPE_RUNTIME, TYPE_JITHELPER);
3788
3789         DUMP_EVENT_STAT (TYPE_COVERAGE, TYPE_COVERAGE_ASSEMBLY);
3790         DUMP_EVENT_STAT (TYPE_COVERAGE, TYPE_COVERAGE_METHOD);
3791         DUMP_EVENT_STAT (TYPE_COVERAGE, TYPE_COVERAGE_STATEMENT);
3792         DUMP_EVENT_STAT (TYPE_COVERAGE, TYPE_COVERAGE_CLASS);
3793 }
3794
3795
3796
3797 static void
3798 flush_context (ProfContext *ctx)
3799 {
3800         ThreadContext *thread;
3801         /* FIXME: sometimes there are leftovers: indagate */
3802         for (thread = ctx->threads; thread; thread = thread->next) {
3803                 while (thread->stack_id) {
3804                         if (debug)
3805                                 fprintf (outfile, "thread %p has %d items on stack\n", (void*)thread->thread_id, thread->stack_id);
3806                         pop_method (thread, thread->stack [thread->stack_id - 1], thread->last_time);
3807                 }
3808         }
3809 }
3810
3811 static const char *reports = "header,jit,gc,sample,alloc,call,metadata,exception,monitor,thread,heapshot,counters,coverage";
3812
3813 static const char*
3814 match_option (const char *p, const char *opt)
3815 {
3816         int len = strlen (opt);
3817         if (strncmp (p, opt, len) == 0) {
3818                 if (p [len] == ',')
3819                         len++;
3820                 return p + len;
3821         }
3822         return p;
3823 }
3824
3825 static int
3826 print_reports (ProfContext *ctx, const char *reps, int parse_only)
3827 {
3828         const char *opt;
3829         const char *p;
3830         for (p = reps; *p; p = opt) {
3831                 if ((opt = match_option (p, "header")) != p) {
3832                         if (!parse_only)
3833                                 dump_header (ctx);
3834                         continue;
3835                 }
3836                 if ((opt = match_option (p, "thread")) != p) {
3837                         if (!parse_only)
3838                                 dump_threads (ctx);
3839                         continue;
3840                 }
3841                 if ((opt = match_option (p, "domain")) != p) {
3842                         if (!parse_only)
3843                                 dump_domains (ctx);
3844                         continue;
3845                 }
3846                 if ((opt = match_option (p, "context")) != p) {
3847                         if (!parse_only)
3848                                 dump_remctxs (ctx);
3849                         continue;
3850                 }
3851                 if ((opt = match_option (p, "gc")) != p) {
3852                         if (!parse_only)
3853                                 dump_gcs ();
3854                         continue;
3855                 }
3856                 if ((opt = match_option (p, "jit")) != p) {
3857                         if (!parse_only)
3858                                 dump_jit ();
3859                         continue;
3860                 }
3861                 if ((opt = match_option (p, "alloc")) != p) {
3862                         if (!parse_only)
3863                                 dump_allocations ();
3864                         continue;
3865                 }
3866                 if ((opt = match_option (p, "call")) != p) {
3867                         if (!parse_only)
3868                                 dump_methods ();
3869                         continue;
3870                 }
3871                 if ((opt = match_option (p, "metadata")) != p) {
3872                         if (!parse_only)
3873                                 dump_metadata ();
3874                         continue;
3875                 }
3876                 if ((opt = match_option (p, "exception")) != p) {
3877                         if (!parse_only)
3878                                 dump_exceptions ();
3879                         continue;
3880                 }
3881                 if ((opt = match_option (p, "monitor")) != p) {
3882                         if (!parse_only)
3883                                 dump_monitors ();
3884                         continue;
3885                 }
3886                 if ((opt = match_option (p, "heapshot")) != p) {
3887                         if (!parse_only)
3888                                 dump_heap_shots ();
3889                         continue;
3890                 }
3891                 if ((opt = match_option (p, "sample")) != p) {
3892                         if (!parse_only)
3893                                 dump_samples ();
3894                         continue;
3895                 }
3896                 if ((opt = match_option (p, "counters")) != p) {
3897                         if (!parse_only)
3898                                 dump_counters ();
3899                         continue;
3900                 }
3901                 if ((opt = match_option (p, "coverage")) != p) {
3902                         if (!parse_only)
3903                                 dump_coverage ();
3904                         continue;
3905                 }
3906                 if ((opt = match_option (p, "stats")) != p) {
3907                         if (!parse_only)
3908                                 dump_stats ();
3909                         continue;
3910                 }
3911                 return 0;
3912         }
3913         return 1;
3914 }
3915
3916 static int
3917 add_find_spec (const char *p)
3918 {
3919         if (p [0] == 'S' && p [1] == ':') {
3920                 char *vale;
3921                 find_size = strtoul (p + 2, &vale, 10);
3922                 return 1;
3923         } else if (p [0] == 'T' && p [1] == ':') {
3924                 find_name = p + 2;
3925                 return 1;
3926         }
3927         return 0;
3928 }
3929
3930 static void
3931 usage (void)
3932 {
3933         printf ("Mono log profiler report version %d.%d\n", LOG_VERSION_MAJOR, LOG_VERSION_MINOR);
3934         printf ("Usage: mprof-report [OPTIONS] FILENAME\n");
3935         printf ("FILENAME can be '-' to read from standard input.\n");
3936         printf ("Options:\n");
3937         printf ("\t--help               display this help\n");
3938         printf ("\t--out=FILE           write to FILE instead of stdout\n");
3939         printf ("\t--traces             collect and show backtraces\n");
3940         printf ("\t--maxframes=NUM      limit backtraces to NUM entries\n");
3941         printf ("\t--reports=R1[,R2...] print the specified reports. Defaults are:\n");
3942         printf ("\t                     %s\n", reports);
3943         printf ("\t--method-sort=MODE   sort methods according to MODE: total, self, calls\n");
3944         printf ("\t--alloc-sort=MODE    sort allocations according to MODE: bytes, count\n");
3945         printf ("\t--counters-sort=MODE sort counters according to MODE: time, category\n");
3946         printf ("\t                     only accessible in verbose mode\n");
3947         printf ("\t--track=OB1[,OB2...] track what happens to objects OBJ1, O2 etc.\n");
3948         printf ("\t--find=FINDSPEC      find and track objects matching FINFSPEC, where FINDSPEC is:\n");
3949         printf ("\t                     S:minimum_size or T:partial_name\n");
3950         printf ("\t--thread=THREADID    consider just the data for thread THREADID\n");
3951         printf ("\t--time=FROM-TO       consider data FROM seconds from startup up to TO seconds\n");
3952         printf ("\t--verbose            increase verbosity level\n");
3953         printf ("\t--debug              display decoding debug info for mprof-report devs\n");
3954         printf ("\t--coverage-out=FILE  write the coverage info to FILE as XML\n");
3955 }
3956
3957 int
3958 main (int argc, char *argv[])
3959 {
3960         ProfContext *ctx;
3961         int i;
3962         outfile = stdout;
3963         for (i = 1; i < argc; ++i) {
3964                 if (strcmp ("--debug", argv [i]) == 0) {
3965                         debug++;
3966                 } else if (strcmp ("--help", argv [i]) == 0) {
3967                         usage ();
3968                         return 0;
3969                 } else if (strncmp ("--alloc-sort=", argv [i], 13) == 0) {
3970                         const char *val = argv [i] + 13;
3971                         if (strcmp (val, "bytes") == 0) {
3972                                 alloc_sort_mode = ALLOC_SORT_BYTES;
3973                         } else if (strcmp (val, "count") == 0) {
3974                                 alloc_sort_mode = ALLOC_SORT_COUNT;
3975                         } else {
3976                                 usage ();
3977                                 return 1;
3978                         }
3979                 } else if (strncmp ("--method-sort=", argv [i], 14) == 0) {
3980                         const char *val = argv [i] + 14;
3981                         if (strcmp (val, "total") == 0) {
3982                                 method_sort_mode = METHOD_SORT_TOTAL;
3983                         } else if (strcmp (val, "self") == 0) {
3984                                 method_sort_mode = METHOD_SORT_SELF;
3985                         } else if (strcmp (val, "calls") == 0) {
3986                                 method_sort_mode = METHOD_SORT_CALLS;
3987                         } else {
3988                                 usage ();
3989                                 return 1;
3990                         }
3991                 } else if (strncmp ("--counters-sort=", argv [i], 16) == 0) {
3992                         const char *val = argv [i] + 16;
3993                         if (strcmp (val, "time") == 0) {
3994                                 counters_sort_mode = COUNTERS_SORT_TIME;
3995                         } else if (strcmp (val, "category") == 0) {
3996                                 counters_sort_mode = COUNTERS_SORT_CATEGORY;
3997                         } else {
3998                                 usage ();
3999                                 return 1;
4000                         }
4001                 } else if (strncmp ("--reports=", argv [i], 10) == 0) {
4002                         const char *val = argv [i] + 10;
4003                         if (!print_reports (NULL, val, 1)) {
4004                                 usage ();
4005                                 return 1;
4006                         }
4007                         reports = val;
4008                 } else if (strncmp ("--out=", argv [i], 6) == 0) {
4009                         const char *val = argv [i] + 6;
4010                         outfile = fopen (val, "w");
4011                         if (!outfile) {
4012                                 printf ("Cannot open output file: %s\n", val);
4013                                 return 1;
4014                         }
4015                 } else if (strncmp ("--maxframes=", argv [i], 12) == 0) {
4016                         const char *val = argv [i] + 12;
4017                         char *vale;
4018                         trace_max = strtoul (val, &vale, 10);
4019                 } else if (strncmp ("--find=", argv [i], 7) == 0) {
4020                         const char *val = argv [i] + 7;
4021                         if (!add_find_spec (val)) {
4022                                 usage ();
4023                                 return 1;
4024                         }
4025                 } else if (strncmp ("--track=", argv [i], 8) == 0) {
4026                         const char *val = argv [i] + 8;
4027                         char *vale;
4028                         while (*val) {
4029                                 uintptr_t tracked_obj;
4030                                 if (*val == ',') {
4031                                         val++;
4032                                         continue;
4033                                 }
4034                                 tracked_obj = strtoul (val, &vale, 0);
4035                                 found_object (tracked_obj);
4036                                 val = vale;
4037                         }
4038                 } else if (strncmp ("--thread=", argv [i], 9) == 0) {
4039                         const char *val = argv [i] + 9;
4040                         char *vale;
4041                         thread_filter = strtoul (val, &vale, 0);
4042                 } else if (strncmp ("--time=", argv [i], 7) == 0) {
4043                         char *val = pstrdup (argv [i] + 7);
4044                         double from_secs, to_secs;
4045                         char *top = strchr (val, '-');
4046                         if (!top) {
4047                                 usage ();
4048                                 return 1;
4049                         }
4050                         *top++ = 0;
4051                         from_secs = atof (val);
4052                         to_secs = atof (top);
4053                         free (val);
4054                         if (from_secs > to_secs) {
4055                                 usage ();
4056                                 return 1;
4057                         }
4058                         time_from = from_secs * 1000000000;
4059                         time_to = to_secs * 1000000000;
4060                         use_time_filter = 1;
4061                 } else if (strcmp ("--verbose", argv [i]) == 0) {
4062                         verbose++;
4063                 } else if (strcmp ("--traces", argv [i]) == 0) {
4064                         show_traces = 1;
4065                         collect_traces = 1;
4066                 } else if (strncmp ("--coverage-out=", argv [i], 15) == 0) {
4067                         const char *val = argv [i] + 15;
4068                         coverage_outfile = fopen (val, "w");
4069                         if (!coverage_outfile) {
4070                                 printf ("Cannot open output file: %s\n", val);
4071                                 return 1;
4072                         }
4073                 } else {
4074                         break;
4075                 }
4076         }
4077         if (i >= argc) {
4078                 usage ();
4079                 return 2;
4080         }
4081         ctx = load_file (argv [i]);
4082         if (!ctx) {
4083                 printf ("Not a log profiler data file (or unsupported version).\n");
4084                 return 1;
4085         }
4086         while (decode_buffer (ctx));
4087         flush_context (ctx);
4088         if (num_tracked_objects)
4089                 return 0;
4090         print_reports (ctx, reports, 0);
4091         return 0;
4092 }