mono/metadata/debug-mono-ppdb.c

   1 /*
   2  * debug-mono-ppdb.c: Support for the portable PDB symbol
   3  * file format
   4  *
   5  *
   6  * Author:
   7  *      Mono Project (http://www.mono-project.com)
   8  *
   9  * Copyright 2015 Xamarin Inc (http://www.xamarin.com)
  10  */
  11
  12 #include <config.h>
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <errno.h>
  16 #include <string.h>
  17 #include <mono/metadata/metadata.h>
  18 #include <mono/metadata/tabledefs.h>
  19 #include <mono/metadata/tokentype.h>
  20 #include <mono/metadata/debug-helpers.h>
  21 #include <mono/metadata/mono-debug.h>
  22 #include <mono/metadata/debug-mono-symfile.h>
  23 #include <mono/metadata/mono-debug-debugger.h>
  24 #include <mono/metadata/mono-endian.h>
  25 #include <mono/metadata/metadata-internals.h>
  26 #include <mono/metadata/class-internals.h>
  27 #include <mono/metadata/cil-coff.h>
  28
  29 #include "debug-mono-ppdb.h"
  30
  31 struct _MonoPPDBFile {
  32         MonoImage *image;
  33         GHashTable *doc_hash;
  34         GHashTable *method_hash;
  35 };
  36
  37 /* IMAGE_DEBUG_DIRECTORY structure */
  38 typedef struct
  39 {
  40         gint32 characteristics;
  41         gint32 time_date_stamp;
  42         gint16 major_version;
  43         gint16 minor_version;
  44         gint32 type;
  45         gint32 size_of_data;
  46         gint32 address;
  47         gint32 pointer;
  48 }  ImageDebugDirectory;
  49
  50 typedef struct {
  51         gint32 signature;
  52         guint8 guid [16];
  53         gint32 age;
  54 } CodeviewDebugDirectory;
  55
  56 typedef struct {
  57         guint8 guid [20];
  58         guint32 entry_point;
  59         guint64 referenced_tables;
  60 } PdbStreamHeader;
  61
  62 static gboolean
  63 get_pe_debug_guid (MonoImage *image, guint8 *out_guid, gint32 *out_age, gint32 *out_timestamp)
  64 {
  65         MonoPEDirEntry *debug_dir_entry;
  66         ImageDebugDirectory *debug_dir;
  67
  68         debug_dir_entry = &((MonoCLIImageInfo*)image->image_info)->cli_header.datadir.pe_debug;
  69         if (!debug_dir_entry->size)
  70                 return FALSE;
  71
  72         int offset = mono_cli_rva_image_map (image, debug_dir_entry->rva);
  73         debug_dir = (ImageDebugDirectory*)(image->raw_data + offset);
  74         if (debug_dir->type == 2 && debug_dir->major_version == 0x100 && debug_dir->minor_version == 0x504d) {
  75                 /* This is a 'CODEVIEW' debug directory */
  76                 CodeviewDebugDirectory *dir = (CodeviewDebugDirectory*)(image->raw_data + debug_dir->pointer);
  77
  78                 if (dir->signature == 0x53445352) {
  79                         memcpy (out_guid, dir->guid, 16);
  80                         *out_age = dir->age;
  81                         *out_timestamp = debug_dir->time_date_stamp;
  82                         return TRUE;
  83                 }
  84         }
  85         return FALSE;
  86 }
  87
  88 static void
  89 doc_free (gpointer key)
  90 {
  91         MonoDebugSourceInfo *info = (MonoDebugSourceInfo *)key;
  92
  93         g_free (info->source_file);
  94         g_free (info);
  95 }
  96
  97 MonoPPDBFile*
  98 mono_ppdb_load_file (MonoImage *image, const guint8 *raw_contents, int size)
  99 {
 100         MonoImage *ppdb_image;
 101         const char *filename;
 102         char *s, *ppdb_filename;
 103         MonoImageOpenStatus status;
 104         guint8 pe_guid [16];
 105         gint32 pe_age;
 106         gint32 pe_timestamp;
 107         MonoPPDBFile *ppdb;
 108
 109         if (raw_contents) {
 110                 ppdb_image = mono_image_open_from_data_internal ((char*)raw_contents, size, TRUE, &status, FALSE, TRUE, NULL);
 111         } else {
 112                 /* ppdb files drop the .exe/.dll extension */
 113                 filename = mono_image_get_filename (image);
 114                 if (strlen (filename) > 4 && (!strcmp (filename + strlen (filename) - 4, ".exe") || !strcmp (filename + strlen (filename) - 4, ".dll"))) {
 115                         s = g_strdup (filename);
 116                         s [strlen (filename) - 4] = '\0';
 117                         ppdb_filename = g_strdup_printf ("%s.pdb", s);
 118                         g_free (s);
 119                 } else {
 120                         ppdb_filename = g_strdup_printf ("%s.pdb", filename);
 121                 }
 122
 123                 ppdb_image = mono_image_open_metadata_only (ppdb_filename, &status);
 124                 if (!ppdb_image)
 125                         g_free (ppdb_filename);
 126         }
 127         if (!ppdb_image)
 128                 return NULL;
 129
 130         /*
 131          * Check that the images match.
 132          * The same id is stored in the Debug Directory of the PE file, and in the
 133          * #Pdb stream in the ppdb file.
 134          */
 135         if (get_pe_debug_guid (image, pe_guid, &pe_age, &pe_timestamp)) {
 136                 PdbStreamHeader *pdb_stream = (PdbStreamHeader*)ppdb_image->heap_pdb.data;
 137
 138                 g_assert (pdb_stream);
 139
 140                 /* The pdb id is a concentation of the pe guid and the timestamp */
 141                 if (memcmp (pe_guid, pdb_stream->guid, 16) != 0 || memcmp (&pe_timestamp, pdb_stream->guid + 16, 4) != 0) {
 142                         g_warning ("Symbol file %s doesn't match image %s", ppdb_image->name,
 143                                            image->name);
 144                         mono_image_close (ppdb_image);
 145                         return NULL;
 146                 }
 147         }
 148
 149         ppdb = g_new0 (MonoPPDBFile, 1);
 150         ppdb->image = ppdb_image;
 151         ppdb->doc_hash = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) doc_free);
 152         ppdb->method_hash = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_free);
 153
 154         return ppdb;
 155 }
 156
 157 void
 158 mono_ppdb_close (MonoDebugHandle *handle)
 159 {
 160         MonoPPDBFile *ppdb = handle->ppdb;
 161
 162         mono_image_close (ppdb->image);
 163         g_hash_table_destroy (ppdb->doc_hash);
 164         g_hash_table_destroy (ppdb->method_hash);
 165         g_free (ppdb);
 166 }
 167
 168 MonoDebugMethodInfo *
 169 mono_ppdb_lookup_method (MonoDebugHandle *handle, MonoMethod *method)
 170 {
 171         MonoDebugMethodInfo *minfo;
 172         MonoPPDBFile *ppdb = handle->ppdb;
 173
 174         if (handle->image != mono_class_get_image (mono_method_get_class (method)))
 175                 return NULL;
 176
 177         mono_debugger_lock ();
 178
 179         minfo = (MonoDebugMethodInfo *)g_hash_table_lookup (ppdb->method_hash, method);
 180         if (minfo) {
 181                 mono_debugger_unlock ();
 182                 return minfo;
 183         }
 184
 185         minfo = g_new0 (MonoDebugMethodInfo, 1);
 186         minfo->index = 0;
 187         minfo->method = method;
 188         minfo->handle = handle;
 189
 190         g_hash_table_insert (ppdb->method_hash, method, minfo);
 191
 192         mono_debugger_unlock ();
 193
 194         return minfo;
 195 }
 196
 197 static MonoDebugSourceInfo*
 198 get_docinfo (MonoPPDBFile *ppdb, MonoImage *image, int docidx)
 199 {
 200         MonoTableInfo *tables = image->tables;
 201         guint32 cols [MONO_DOCUMENT_SIZE];
 202         const char *ptr;
 203         const char *start;
 204         const char *part_ptr;
 205         int size, part_size, partidx, nparts;
 206         char sep;
 207         GString *s;
 208         MonoDebugSourceInfo *res, *cached;
 209
 210         mono_debugger_lock ();
 211         cached = (MonoDebugSourceInfo *)g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
 212         mono_debugger_unlock ();
 213         if (cached)
 214                 return cached;
 215
 216         mono_metadata_decode_row (&tables [MONO_TABLE_DOCUMENT], docidx-1, cols, MONO_DOCUMENT_SIZE);
 217
 218         ptr = mono_metadata_blob_heap (image, cols [MONO_DOCUMENT_NAME]);
 219         size = mono_metadata_decode_blob_size (ptr, &ptr);
 220         start = ptr;
 221
 222         // FIXME: UTF8
 223         sep = ptr [0];
 224         ptr ++;
 225
 226         s = g_string_new ("");
 227
 228         nparts = 0;
 229         while (ptr < start + size) {
 230                 partidx = mono_metadata_decode_value (ptr, &ptr);
 231                 if (nparts)
 232                         g_string_append_c (s, sep);
 233                 if (partidx) {
 234                         part_ptr = mono_metadata_blob_heap (image, partidx);
 235                         part_size = mono_metadata_decode_blob_size (part_ptr, &part_ptr);
 236
 237                         // FIXME: UTF8
 238                         g_string_append_len (s, part_ptr, part_size);
 239                 }
 240                 nparts ++;
 241         }
 242
 243         res = g_new0 (MonoDebugSourceInfo, 1);
 244         res->source_file = g_string_free (s, FALSE);
 245         res->guid = NULL;
 246         res->hash = (guint8*)mono_metadata_blob_heap (image, cols [MONO_DOCUMENT_HASH]);
 247
 248         mono_debugger_lock ();
 249         cached = (MonoDebugSourceInfo *)g_hash_table_lookup (ppdb->doc_hash, GUINT_TO_POINTER (docidx));
 250         if (!cached) {
 251                 g_hash_table_insert (ppdb->doc_hash, GUINT_TO_POINTER (docidx), res);
 252         } else {
 253                 doc_free (res);
 254                 res = cached;
 255         }
 256         mono_debugger_unlock ();
 257         return res;
 258 }
 259
 260 static char*
 261 get_docname (MonoPPDBFile *ppdb, MonoImage *image, int docidx)
 262 {
 263         MonoDebugSourceInfo *info;
 264
 265         info = get_docinfo (ppdb, image, docidx);
 266         return g_strdup (info->source_file);
 267 }
 268
 269 /**
 270  * mono_ppdb_lookup_location:
 271  * @minfo: A `MonoDebugMethodInfo' which can be retrieved by
 272  *         mono_debug_lookup_method().
 273  * @offset: IL offset within the corresponding method's CIL code.
 274  *
 275  * This function is similar to mono_debug_lookup_location(), but we
 276  * already looked up the method and also already did the
 277  * `native address -> IL offset' mapping.
 278  */
 279 MonoDebugSourceLocation *
 280 mono_ppdb_lookup_location (MonoDebugMethodInfo *minfo, uint32_t offset)
 281 {
 282         MonoPPDBFile *ppdb = minfo->handle->ppdb;
 283         MonoImage *image = ppdb->image;
 284         MonoMethod *method = minfo->method;
 285         MonoTableInfo *tables = image->tables;
 286         guint32 cols [MONO_METHODBODY_SIZE];
 287         const char *ptr;
 288         const char *end;
 289         char *docname;
 290         int idx, size, docidx, iloffset, delta_il, delta_lines, delta_cols, start_line, start_col, adv_line, adv_col;
 291         gboolean first = TRUE, first_non_hidden = TRUE;
 292         MonoDebugSourceLocation *location;
 293
 294         g_assert (method->token);
 295
 296         idx = mono_metadata_token_index (method->token);
 297
 298         mono_metadata_decode_row (&tables [MONO_TABLE_METHODBODY], idx-1, cols, MONO_METHODBODY_SIZE);
 299
 300         docidx = cols [MONO_METHODBODY_DOCUMENT];
 301
 302         if (!cols [MONO_METHODBODY_SEQ_POINTS])
 303                 return NULL;
 304         ptr = mono_metadata_blob_heap (image, cols [MONO_METHODBODY_SEQ_POINTS]);
 305         size = mono_metadata_decode_blob_size (ptr, &ptr);
 306         end = ptr + size;
 307
 308         /* Header */
 309         /* LocalSignature */
 310         mono_metadata_decode_value (ptr, &ptr);
 311         if (docidx == 0)
 312                 docidx = mono_metadata_decode_value (ptr, &ptr);
 313         docname = get_docname (ppdb, image, docidx);
 314
 315         iloffset = 0;
 316         start_line = 0;
 317         start_col = 0;
 318         while (ptr < end) {
 319                 delta_il = mono_metadata_decode_value (ptr, &ptr);
 320                 if (!first && delta_il == 0) {
 321                         /* document-record */
 322                         docidx = mono_metadata_decode_value (ptr, &ptr);
 323                         docname = get_docname (ppdb, image, docidx);
 324                         continue;
 325                 }
 326                 if (!first && iloffset + delta_il > offset)
 327                         break;
 328                 iloffset += delta_il;
 329                 first = FALSE;
 330
 331                 delta_lines = mono_metadata_decode_value (ptr, &ptr);
 332                 if (delta_lines == 0)
 333                         delta_cols = mono_metadata_decode_value (ptr, &ptr);
 334                 else
 335                         delta_cols = mono_metadata_decode_signed_value (ptr, &ptr);
 336                 if (delta_lines == 0 && delta_cols == 0)
 337                         /* hidden-sequence-point-record */
 338                         continue;
 339                 if (first_non_hidden) {
 340                         start_line = mono_metadata_decode_value (ptr, &ptr);
 341                         start_col = mono_metadata_decode_value (ptr, &ptr);
 342                 } else {
 343                         adv_line = mono_metadata_decode_signed_value (ptr, &ptr);
 344                         adv_col = mono_metadata_decode_signed_value (ptr, &ptr);
 345                         start_line += adv_line;
 346                         start_col += adv_col;
 347                 }
 348                 first_non_hidden = FALSE;
 349         }
 350
 351         location = g_new0 (MonoDebugSourceLocation, 1);
 352         location->source_file = docname;
 353         location->row = start_line;
 354         location->il_offset = iloffset;
 355
 356         return location;
 357 }
 358
 359 void
 360 mono_ppdb_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points)
 361 {
 362         MonoPPDBFile *ppdb = minfo->handle->ppdb;
 363         MonoImage *image = ppdb->image;
 364         MonoMethod *method = minfo->method;
 365         MonoTableInfo *tables = image->tables;
 366         guint32 cols [MONO_METHODBODY_SIZE];
 367         const char *ptr;
 368         const char *end;
 369         MonoDebugSourceInfo *docinfo;
 370         int i, method_idx, size, docidx, iloffset, delta_il, delta_lines, delta_cols, start_line, start_col, adv_line, adv_col;
 371         gboolean first = TRUE, first_non_hidden = TRUE;
 372         GArray *sps;
 373         MonoSymSeqPoint sp;
 374         GPtrArray *sfiles = NULL;
 375         GPtrArray *sindexes = NULL;
 376
 377         if (source_file)
 378                 *source_file = NULL;
 379         if (source_file_list)
 380                 *source_file_list = NULL;
 381         if (source_files)
 382                 *source_files = NULL;
 383         if (seq_points)
 384                 *seq_points = NULL;
 385         if (n_seq_points)
 386                 *n_seq_points = 0;
 387
 388         if (source_file_list)
 389                 *source_file_list = sfiles = g_ptr_array_new ();
 390         if (source_files)
 391                 sindexes = g_ptr_array_new ();
 392
 393         if (!method->token)
 394                 return;
 395
 396         method_idx = mono_metadata_token_index (method->token);
 397
 398         mono_metadata_decode_row (&tables [MONO_TABLE_METHODBODY], method_idx-1, cols, MONO_METHODBODY_SIZE);
 399
 400         docidx = cols [MONO_METHODBODY_DOCUMENT];
 401
 402         if (!cols [MONO_METHODBODY_SEQ_POINTS])
 403                 return;
 404
 405         ptr = mono_metadata_blob_heap (image, cols [MONO_METHODBODY_SEQ_POINTS]);
 406         size = mono_metadata_decode_blob_size (ptr, &ptr);
 407         end = ptr + size;
 408
 409         sps = g_array_new (FALSE, TRUE, sizeof (MonoSymSeqPoint));
 410
 411         /* Header */
 412         /* LocalSignature */
 413         mono_metadata_decode_value (ptr, &ptr);
 414         if (docidx == 0)
 415                 docidx = mono_metadata_decode_value (ptr, &ptr);
 416         docinfo = get_docinfo (ppdb, image, docidx);
 417
 418         if (sfiles)
 419                 g_ptr_array_add (sfiles, docinfo);
 420
 421         iloffset = 0;
 422         start_line = 0;
 423         start_col = 0;
 424         while (ptr < end) {
 425                 delta_il = mono_metadata_decode_value (ptr, &ptr);
 426                 if (!first && delta_il == 0) {
 427                         /* subsequent-document-record */
 428                         docidx = mono_metadata_decode_value (ptr, &ptr);
 429                         docinfo = get_docinfo (ppdb, image, docidx);
 430                         if (sfiles)
 431                                 g_ptr_array_add (sfiles, docinfo);
 432                         continue;
 433                 }
 434                 iloffset += delta_il;
 435                 first = FALSE;
 436
 437                 delta_lines = mono_metadata_decode_value (ptr, &ptr);
 438                 if (delta_lines == 0)
 439                         delta_cols = mono_metadata_decode_value (ptr, &ptr);
 440                 else
 441                         delta_cols = mono_metadata_decode_signed_value (ptr, &ptr);
 442
 443                 if (delta_lines == 0 && delta_cols == 0) {
 444                         /* Hidden sequence point */
 445                         continue;
 446                 }
 447
 448                 if (first_non_hidden) {
 449                         start_line = mono_metadata_decode_value (ptr, &ptr);
 450                         start_col = mono_metadata_decode_value (ptr, &ptr);
 451                 } else {
 452                         adv_line = mono_metadata_decode_signed_value (ptr, &ptr);
 453                         adv_col = mono_metadata_decode_signed_value (ptr, &ptr);
 454                         start_line += adv_line;
 455                         start_col += adv_col;
 456                 }
 457                 first_non_hidden = FALSE;
 458
 459                 memset (&sp, 0, sizeof (sp));
 460                 sp.il_offset = iloffset;
 461                 sp.line = start_line;
 462                 sp.column = start_col;
 463                 sp.end_line = start_line + delta_lines;
 464                 sp.end_column = start_col + delta_cols;
 465
 466                 g_array_append_val (sps, sp);
 467                 if (source_files)
 468                         g_ptr_array_add (sindexes, GUINT_TO_POINTER (sfiles->len - 1));
 469         }
 470
 471         if (n_seq_points) {
 472                 *n_seq_points = sps->len;
 473                 g_assert (seq_points);
 474                 *seq_points = g_new (MonoSymSeqPoint, sps->len);
 475                 memcpy (*seq_points, sps->data, sps->len * sizeof (MonoSymSeqPoint));
 476         }
 477
 478         if (source_file)
 479                 *source_file = g_strdup (((MonoDebugSourceInfo*)g_ptr_array_index (sfiles, 0))->source_file);
 480         if (source_files) {
 481                 *source_files = g_new (int, sps->len);
 482                 for (i = 0; i < sps->len; ++i)
 483                         (*source_files)[i] = GPOINTER_TO_INT (g_ptr_array_index (sindexes, i));
 484                 g_ptr_array_free (sindexes, TRUE);
 485         }
 486
 487         g_array_free (sps, TRUE);
 488 }
 489
 490 MonoDebugLocalsInfo*
 491 mono_ppdb_lookup_locals (MonoDebugMethodInfo *minfo)
 492 {
 493         MonoPPDBFile *ppdb = minfo->handle->ppdb;
 494         MonoImage *image = ppdb->image;
 495         MonoTableInfo *tables = image->tables;
 496         MonoMethod *method = minfo->method;
 497         guint32 cols [MONO_LOCALSCOPE_SIZE];
 498         guint32 locals_cols [MONO_LOCALVARIABLE_SIZE];
 499         int i, lindex, sindex, method_idx, start_scope_idx, scope_idx, locals_idx, locals_end_idx, nscopes;
 500         MonoDebugLocalsInfo *res;
 501         MonoMethodSignature *sig;
 502
 503         if (!method->token)
 504                 return NULL;
 505
 506         sig = mono_method_signature (method);
 507         if (!sig)
 508                 return NULL;
 509
 510         method_idx = mono_metadata_token_index (method->token);
 511
 512         start_scope_idx = mono_metadata_localscope_from_methoddef (image, method_idx);
 513
 514         if (!start_scope_idx)
 515                 return NULL;
 516
 517         /* Compute number of locals and scopes */
 518         scope_idx = start_scope_idx;
 519         mono_metadata_decode_row (&tables [MONO_TABLE_LOCALSCOPE], scope_idx-1, cols, MONO_LOCALSCOPE_SIZE);
 520         locals_idx = cols [MONO_LOCALSCOPE_VARIABLELIST];
 521         while (scope_idx == tables [MONO_TABLE_LOCALSCOPE].rows) {
 522                 mono_metadata_decode_row (&tables [MONO_TABLE_LOCALSCOPE], scope_idx-1, cols, MONO_LOCALSCOPE_SIZE);
 523                 if (cols [MONO_LOCALSCOPE_METHOD] != method_idx)
 524                         break;
 525                 scope_idx ++;
 526         }
 527         nscopes = scope_idx - start_scope_idx;
 528         if (scope_idx == tables [MONO_TABLE_LOCALSCOPE].rows) {
 529                 locals_end_idx = tables [MONO_TABLE_LOCALVARIABLE].rows;
 530         } else {
 531                 locals_end_idx = cols [MONO_LOCALSCOPE_VARIABLELIST];
 532         }
 533
 534         res = g_new0 (MonoDebugLocalsInfo, 1);
 535         res->num_blocks = nscopes;
 536         res->code_blocks = g_new0 (MonoDebugCodeBlock, res->num_blocks);
 537         res->num_locals = locals_end_idx - locals_idx;
 538         res->locals = g_new0 (MonoDebugLocalVar, res->num_locals);
 539
 540         lindex = 0;
 541         for (sindex = 0; sindex < nscopes; ++sindex) {
 542                 scope_idx = start_scope_idx + sindex;
 543                 mono_metadata_decode_row (&tables [MONO_TABLE_LOCALSCOPE], scope_idx-1, cols, MONO_LOCALSCOPE_SIZE);
 544
 545                 locals_idx = cols [MONO_LOCALSCOPE_VARIABLELIST];
 546                 if (scope_idx == tables [MONO_TABLE_LOCALSCOPE].rows) {
 547                         locals_end_idx = tables [MONO_TABLE_LOCALVARIABLE].rows;
 548                 } else {
 549                         locals_end_idx = mono_metadata_decode_row_col (&tables [MONO_TABLE_LOCALSCOPE], scope_idx-1 + 1, MONO_LOCALSCOPE_VARIABLELIST);
 550                 }
 551
 552                 res->code_blocks [sindex].start_offset = cols [MONO_LOCALSCOPE_STARTOFFSET];
 553                 res->code_blocks [sindex].end_offset = cols [MONO_LOCALSCOPE_STARTOFFSET] + cols [MONO_LOCALSCOPE_LENGTH];
 554
 555                 //printf ("Scope: %s %d %d %d-%d\n", mono_method_full_name (method, 1), cols [MONO_LOCALSCOPE_STARTOFFSET], cols [MONO_LOCALSCOPE_LENGTH], locals_idx, locals_end_idx);
 556
 557                 for (i = locals_idx; i < locals_end_idx; ++i) {
 558                         mono_metadata_decode_row (&tables [MONO_TABLE_LOCALVARIABLE], i - 1, locals_cols, MONO_LOCALVARIABLE_SIZE);
 559
 560                         res->locals [lindex].name = g_strdup (mono_metadata_string_heap (image, locals_cols [MONO_LOCALVARIABLE_NAME]));
 561                         res->locals [lindex].index = locals_cols [MONO_LOCALVARIABLE_INDEX];
 562                         res->locals [lindex].block = &res->code_blocks [sindex];
 563                         lindex ++;
 564
 565                         //printf ("\t %s %d\n", mono_metadata_string_heap (image, locals_cols [MONO_LOCALVARIABLE_NAME]), locals_cols [MONO_LOCALVARIABLE_INDEX]);
 566                 }
 567         }
 568
 569         return res;
 570 }