2 * debug-mono-symfile.c:
5 * Mono Project (http://www.mono-project.com)
7 * Copyright (C) 2005-2008 Novell, Inc. (http://www.novell.com)
8 * Copyright 2012 Xamarin Inc (http://www.xamarin.com)
16 #ifdef HAVE_SYS_PARAM_H
17 #include <sys/param.h>
20 #include <mono/metadata/metadata.h>
21 #include <mono/metadata/tabledefs.h>
22 #include <mono/metadata/tokentype.h>
23 #include <mono/metadata/appdomain.h>
24 #include <mono/metadata/exception.h>
25 #include <mono/metadata/debug-helpers.h>
26 #include <mono/metadata/mono-debug.h>
27 #include <mono/metadata/debug-mono-symfile.h>
28 #include <mono/metadata/mono-debug-debugger.h>
29 #include <mono/metadata/mono-endian.h>
30 #include <mono/metadata/metadata-internals.h>
31 #include <mono/metadata/class-internals.h>
32 #include <mono/utils/mono-mmap.h>
33 #include <mono/utils/bsearch.h>
40 #define RANGE_TABLE_CHUNK_SIZE 256
41 #define CLASS_TABLE_CHUNK_SIZE 256
42 #define TYPE_TABLE_PTR_CHUNK_SIZE 256
43 #define TYPE_TABLE_CHUNK_SIZE 65536
45 struct _MonoSymbolFile
{
46 const uint8_t *raw_contents
;
47 int raw_contents_size
;
48 void *raw_contents_handle
;
52 GHashTable
*method_hash
;
53 GHashTable
*source_hash
;
54 MonoSymbolFileOffsetTable
*offset_table
;
55 gboolean was_loaded_from_memory
;
59 free_method_info (MonoDebugMethodInfo
*minfo
)
65 free_source_info (MonoDebugSourceInfo
*sinfo
)
67 g_free (sinfo
->source_file
);
74 load_symfile (MonoDebugHandle
*handle
, MonoSymbolFile
*symfile
, mono_bool in_the_debugger
)
76 const char *ptr
, *start
;
81 ptr
= start
= (const char*)symfile
->raw_contents
;
86 ptr
+= sizeof(uint64_t);
87 if (magic
!= MONO_SYMBOL_FILE_MAGIC
) {
89 g_warning ("Symbol file %s is not a mono symbol file", symfile
->filename
);
94 ptr
+= sizeof(uint32_t);
96 ptr
+= sizeof(uint32_t);
99 * 50.0 is the frozen version for Mono 2.0.
101 * Nobody except me (Martin) is allowed to check the minor version.
103 if (major
!= MONO_SYMBOL_FILE_MAJOR_VERSION
) {
104 if (!in_the_debugger
)
105 g_warning ("Symbol file %s has incorrect version (expected %d.%d, got %d)",
106 symfile
->filename
, MONO_SYMBOL_FILE_MAJOR_VERSION
,
107 MONO_SYMBOL_FILE_MINOR_VERSION
, major
);
111 guid
= mono_guid_to_string ((const uint8_t *) ptr
);
114 if (strcmp (handle
->image
->guid
, guid
)) {
115 if (!in_the_debugger
)
116 g_warning ("Symbol file %s doesn't match image %s", symfile
->filename
,
117 handle
->image
->name
);
123 symfile
->major_version
= major
;
124 symfile
->minor_version
= minor
;
126 symfile
->offset_table
= (MonoSymbolFileOffsetTable
*) ptr
;
128 symfile
->method_hash
= g_hash_table_new_full (
129 NULL
, NULL
, NULL
, (GDestroyNotify
) free_method_info
);
131 symfile
->source_hash
= g_hash_table_new_full (
132 NULL
, NULL
, NULL
, (GDestroyNotify
) free_source_info
);
139 mono_debug_open_mono_symbols (MonoDebugHandle
*handle
, const uint8_t *raw_contents
,
140 int size
, gboolean in_the_debugger
)
142 MonoSymbolFile
*symfile
;
144 mono_debugger_lock ();
145 symfile
= g_new0 (MonoSymbolFile
, 1);
147 if (raw_contents
!= NULL
) {
149 symfile
->raw_contents_size
= size
;
150 symfile
->raw_contents
= p
= g_malloc (size
);
151 memcpy (p
, raw_contents
, size
);
152 symfile
->filename
= g_strdup_printf ("LoadedFromMemory");
153 symfile
->was_loaded_from_memory
= TRUE
;
157 symfile
->filename
= g_strdup_printf ("%s.mdb", mono_image_get_filename (handle
->image
));
158 symfile
->was_loaded_from_memory
= FALSE
;
159 if ((f
= mono_file_map_open (symfile
->filename
))) {
160 symfile
->raw_contents_size
= mono_file_map_size (f
);
161 if (symfile
->raw_contents_size
== 0) {
162 if (!in_the_debugger
)
163 g_warning ("stat of %s failed: %s",
164 symfile
->filename
, g_strerror (errno
));
166 symfile
->raw_contents
= mono_file_map (symfile
->raw_contents_size
, MONO_MMAP_READ
|MONO_MMAP_PRIVATE
, mono_file_map_fd (f
), 0, &symfile
->raw_contents_handle
);
169 mono_file_map_close (f
);
173 if (load_symfile (handle
, symfile
, in_the_debugger
)) {
174 mono_debugger_unlock ();
176 } else if (!in_the_debugger
) {
177 mono_debug_close_mono_symbol_file (symfile
);
178 mono_debugger_unlock ();
182 mono_debugger_unlock ();
187 mono_debug_close_mono_symbol_file (MonoSymbolFile
*symfile
)
192 mono_debugger_lock ();
193 if (symfile
->method_hash
)
194 g_hash_table_destroy (symfile
->method_hash
);
196 if (symfile
->raw_contents
) {
197 if (symfile
->was_loaded_from_memory
)
198 g_free ((gpointer
)symfile
->raw_contents
);
200 mono_file_unmap ((gpointer
) symfile
->raw_contents
, symfile
->raw_contents_handle
);
203 if (symfile
->filename
)
204 g_free (symfile
->filename
);
206 mono_debugger_unlock ();
210 mono_debug_symfile_is_loaded (MonoSymbolFile
*symfile
)
212 return symfile
&& symfile
->offset_table
;
217 read_leb128 (const uint8_t *ptr
, const uint8_t **rptr
)
226 ret
= ret
| ((b
& 0x7f) << shift
);
228 } while ((b
& 0x80) == 0x80);
237 read_string (const uint8_t *ptr
, const uint8_t **endp
)
240 int len
= read_leb128 (ptr
, &ptr
);
242 s
= g_filename_from_utf8 ((const char *) ptr
, len
, NULL
, NULL
, NULL
);
250 MonoSymbolFile
*symfile
;
251 int line_base
, line_range
, max_address_incr
;
253 uint32_t last_line
, last_file
, last_offset
;
255 int line
, file
, offset
;
260 check_line (StatementMachine
*stm
, int offset
, MonoDebugSourceLocation
**location
)
262 gchar
*source_file
= NULL
;
264 if (stm
->offset
<= offset
) {
265 stm
->last_offset
= stm
->offset
;
266 stm
->last_file
= stm
->file
;
267 if (stm
->line
!= 0xfeefee)
268 stm
->last_line
= stm
->line
;
272 if (stm
->last_file
) {
273 int offset
= read32(&(stm
->symfile
->offset_table
->_source_table_offset
)) +
274 (stm
->last_file
- 1) * sizeof (MonoSymbolFileSourceEntry
);
275 MonoSymbolFileSourceEntry
*se
= (MonoSymbolFileSourceEntry
*)
276 (stm
->symfile
->raw_contents
+ offset
);
278 source_file
= read_string (stm
->symfile
->raw_contents
+ read32(&(se
->_data_offset
)), NULL
);
281 if (stm
->last_line
== 0) {
283 * The IL offset is less than the first IL offset which has a corresponding
290 *location
= g_new0 (MonoDebugSourceLocation
, 1);
291 (*location
)->source_file
= source_file
;
292 (*location
)->row
= stm
->last_line
;
293 (*location
)->il_offset
= stm
->last_offset
;
298 * mono_debug_symfile_lookup_location:
299 * @minfo: A `MonoDebugMethodInfo' which can be retrieved by
300 * mono_debug_lookup_method().
301 * @offset: IL offset within the corresponding method's CIL code.
303 * This function is similar to mono_debug_lookup_location(), but we
304 * already looked up the method and also already did the
305 * `native address -> IL offset' mapping.
307 MonoDebugSourceLocation
*
308 mono_debug_symfile_lookup_location (MonoDebugMethodInfo
*minfo
, uint32_t offset
)
310 MonoDebugSourceLocation
*location
= NULL
;
311 MonoSymbolFile
*symfile
;
312 const unsigned char *ptr
;
313 StatementMachine stm
;
315 #define DW_LNS_copy 1
316 #define DW_LNS_advance_pc 2
317 #define DW_LNS_advance_line 3
318 #define DW_LNS_set_file 4
319 #define DW_LNS_const_add_pc 8
321 #define DW_LNE_end_sequence 1
322 #define DW_LNE_MONO_negate_is_hidden 0x40
324 #define DW_LNE_MONO__extensions_start 0x40
325 #define DW_LNE_MONO__extensions_end 0x7f
327 if ((symfile
= minfo
->handle
->symfile
) == NULL
)
330 stm
.line_base
= read32 (&symfile
->offset_table
->_line_number_table_line_base
);
331 stm
.line_range
= read32 (&symfile
->offset_table
->_line_number_table_line_range
);
332 stm
.opcode_base
= (uint8_t) read32 (&symfile
->offset_table
->_line_number_table_opcode_base
);
333 stm
.max_address_incr
= (255 - stm
.opcode_base
) / stm
.line_range
;
335 mono_debugger_lock ();
337 ptr
= symfile
->raw_contents
+ minfo
->lnt_offset
;
339 stm
.symfile
= symfile
;
340 stm
.offset
= stm
.last_offset
= 0;
346 stm
.is_hidden
= FALSE
;
349 uint8_t opcode
= *ptr
++;
352 uint8_t size
= *ptr
++;
353 const unsigned char *end_ptr
= ptr
+ size
;
357 if (opcode
== DW_LNE_end_sequence
) {
358 if (check_line (&stm
, -1, &location
))
361 } else if (opcode
== DW_LNE_MONO_negate_is_hidden
) {
362 stm
.is_hidden
= !stm
.is_hidden
;
363 } else if ((opcode
>= DW_LNE_MONO__extensions_start
) &&
364 (opcode
<= DW_LNE_MONO__extensions_end
)) {
365 ; // reserved for future extensions
367 g_warning ("Unknown extended opcode %x in LNT", opcode
);
372 } else if (opcode
< stm
.opcode_base
) {
375 if (check_line (&stm
, offset
, &location
))
378 case DW_LNS_advance_pc
:
379 stm
.offset
+= read_leb128 (ptr
, &ptr
);
381 case DW_LNS_advance_line
:
382 stm
.line
+= read_leb128 (ptr
, &ptr
);
384 case DW_LNS_set_file
:
385 stm
.file
= read_leb128 (ptr
, &ptr
);
387 case DW_LNS_const_add_pc
:
388 stm
.offset
+= stm
.max_address_incr
;
391 g_warning ("Unknown standard opcode %x in LNT", opcode
);
395 opcode
-= stm
.opcode_base
;
397 stm
.offset
+= opcode
/ stm
.line_range
;
398 stm
.line
+= stm
.line_base
+ (opcode
% stm
.line_range
);
400 if (check_line (&stm
, offset
, &location
))
406 mono_debugger_unlock ();
410 mono_debugger_unlock ();
415 add_line (StatementMachine
*stm
, GPtrArray
*il_offset_array
, GPtrArray
*line_number_array
, GPtrArray
*source_file_array
, GPtrArray
*hidden_array
)
417 g_ptr_array_add (il_offset_array
, GUINT_TO_POINTER (stm
->offset
));
418 g_ptr_array_add (line_number_array
, GUINT_TO_POINTER (stm
->line
));
419 g_ptr_array_add (source_file_array
, GUINT_TO_POINTER (stm
->file
));
420 g_ptr_array_add (hidden_array
, GUINT_TO_POINTER (stm
->is_hidden
|| stm
->line
<= 0));
422 if (!stm
->is_hidden
&& !stm
->first_file
)
423 stm
->first_file
= stm
->file
;
427 * mono_debug_symfile_free_location:
429 * Free a MonoDebugSourceLocation returned by
430 * mono_debug_symfile_lookup_location
433 mono_debug_symfile_free_location (MonoDebugSourceLocation
*location
)
435 g_free (location
->source_file
);
440 * LOCKING: Assumes the debugger lock is held.
442 static MonoDebugSourceInfo
*
443 get_source_info (MonoSymbolFile
*symfile
, int index
)
445 MonoDebugSourceInfo
*info
;
447 info
= g_hash_table_lookup (symfile
->source_hash
, GUINT_TO_POINTER (index
));
449 int offset
= read32(&(symfile
->offset_table
->_source_table_offset
)) +
450 (index
- 1) * sizeof (MonoSymbolFileSourceEntry
);
451 MonoSymbolFileSourceEntry
*se
= (MonoSymbolFileSourceEntry
*)
452 (symfile
->raw_contents
+ offset
);
453 const uint8_t *ptr
= symfile
->raw_contents
+ read32(&(se
->_data_offset
));
455 info
= g_new0 (MonoDebugSourceInfo
, 1);
456 info
->source_file
= read_string (ptr
, &ptr
);
457 info
->guid
= g_malloc0 (16);
458 memcpy (info
->guid
, ptr
, 16);
460 info
->hash
= g_malloc0 (16);
461 memcpy (info
->hash
, ptr
, 16);
463 g_hash_table_insert (symfile
->source_hash
, GUINT_TO_POINTER (index
), info
);
469 LNT_FLAG_HAS_COLUMN_INFO
= 1 << 1,
470 LNT_FLAG_HAS_END_INFO
= 1 << 2,
471 } LineNumberTableFlags
;
473 static LineNumberTableFlags
474 method_get_lnt_flags (MonoDebugMethodInfo
*minfo
)
476 MonoSymbolFile
*symfile
;
477 const unsigned char *ptr
;
480 if ((symfile
= minfo
->handle
->symfile
) == NULL
)
483 ptr
= symfile
->raw_contents
+ minfo
->data_offset
;
485 /* Has to read 'flags' which is preceeded by a bunch of other data */
486 /* compile_unit_index */
487 read_leb128 (ptr
, &ptr
);
488 /* local variable table offset */
489 read_leb128 (ptr
, &ptr
);
491 read_leb128 (ptr
, &ptr
);
492 /* code block table offset */
493 read_leb128 (ptr
, &ptr
);
494 /* scope variable table offset */
495 read_leb128 (ptr
, &ptr
);
496 /* real name offset */
497 read_leb128 (ptr
, &ptr
);
499 flags
= read_leb128 (ptr
, &ptr
);
504 * mono_debug_symfile_get_seq_points:
506 * On return, SOURCE_FILE_LIST will point to a GPtrArray of MonoDebugSourceFile
507 * structures, and SOURCE_FILES will contain indexes into this array.
508 * The MonoDebugSourceFile structures are owned by this module.
511 mono_debug_symfile_get_seq_points (MonoDebugMethodInfo
*minfo
, char **source_file
, GPtrArray
**source_file_list
, int **source_files
, MonoSymSeqPoint
**seq_points
, int *n_seq_points
)
513 // FIXME: Unify this with mono_debug_symfile_lookup_location
514 MonoSymbolFile
*symfile
;
515 const unsigned char *ptr
;
516 StatementMachine stm
;
518 LineNumberTableFlags flags
;
519 GPtrArray
*il_offset_array
, *line_number_array
, *source_file_array
, *hidden_array
;
520 gboolean has_column_info
, has_end_info
;
521 MonoSymSeqPoint
*sps
;
523 if (source_file_list
)
524 *source_file_list
= NULL
;
530 *source_files
= NULL
;
534 if ((symfile
= minfo
->handle
->symfile
) == NULL
)
537 flags
= method_get_lnt_flags (minfo
);
538 has_column_info
= (flags
& LNT_FLAG_HAS_COLUMN_INFO
) > 0;
539 has_end_info
= (flags
& LNT_FLAG_HAS_END_INFO
) > 0;
541 il_offset_array
= g_ptr_array_new ();
542 line_number_array
= g_ptr_array_new ();
543 source_file_array
= g_ptr_array_new ();
544 hidden_array
= g_ptr_array_new();
546 stm
.line_base
= read32 (&symfile
->offset_table
->_line_number_table_line_base
);
547 stm
.line_range
= read32 (&symfile
->offset_table
->_line_number_table_line_range
);
548 stm
.opcode_base
= (uint8_t) read32 (&symfile
->offset_table
->_line_number_table_opcode_base
);
549 stm
.max_address_incr
= (255 - stm
.opcode_base
) / stm
.line_range
;
551 mono_debugger_lock ();
553 ptr
= symfile
->raw_contents
+ minfo
->lnt_offset
;
555 stm
.symfile
= symfile
;
556 stm
.offset
= stm
.last_offset
= 0;
562 stm
.is_hidden
= FALSE
;
565 uint8_t opcode
= *ptr
++;
568 uint8_t size
= *ptr
++;
569 const unsigned char *end_ptr
= ptr
+ size
;
573 if (opcode
== DW_LNE_end_sequence
) {
574 if (il_offset_array
->len
== 0)
578 } else if (opcode
== DW_LNE_MONO_negate_is_hidden
) {
579 stm
.is_hidden
= !stm
.is_hidden
;
580 } else if ((opcode
>= DW_LNE_MONO__extensions_start
) &&
581 (opcode
<= DW_LNE_MONO__extensions_end
)) {
582 ; // reserved for future extensions
584 g_warning ("Unknown extended opcode %x in LNT", opcode
);
589 } else if (opcode
< stm
.opcode_base
) {
592 add_line (&stm
, il_offset_array
, line_number_array
, source_file_array
, hidden_array
);
594 case DW_LNS_advance_pc
:
595 stm
.offset
+= read_leb128 (ptr
, &ptr
);
597 case DW_LNS_advance_line
:
598 stm
.line
+= read_leb128 (ptr
, &ptr
);
600 case DW_LNS_set_file
:
601 stm
.file
= read_leb128 (ptr
, &ptr
);
603 case DW_LNS_const_add_pc
:
604 stm
.offset
+= stm
.max_address_incr
;
607 g_warning ("Unknown standard opcode %x in LNT", opcode
);
608 g_assert_not_reached ();
611 opcode
-= stm
.opcode_base
;
613 stm
.offset
+= opcode
/ stm
.line_range
;
614 stm
.line
+= stm
.line_base
+ (opcode
% stm
.line_range
);
616 add_line (&stm
, il_offset_array
, line_number_array
, source_file_array
, hidden_array
);
620 if (!stm
.file
&& stm
.first_file
)
621 stm
.file
= stm
.first_file
;
623 if (stm
.file
&& source_file
) {
624 int offset
= read32(&(stm
.symfile
->offset_table
->_source_table_offset
)) +
625 (stm
.file
- 1) * sizeof (MonoSymbolFileSourceEntry
);
626 MonoSymbolFileSourceEntry
*se
= (MonoSymbolFileSourceEntry
*)
627 (stm
.symfile
->raw_contents
+ offset
);
630 *source_file
= read_string (stm
.symfile
->raw_contents
+ read32(&(se
->_data_offset
)), NULL
);
633 if (source_file_list
) {
634 int file
, last_file
= 0;
636 *source_file_list
= g_ptr_array_new ();
638 *source_files
= g_malloc (il_offset_array
->len
* sizeof (int));
640 for (i
= 0; i
< il_offset_array
->len
; ++i
) {
641 file
= GPOINTER_TO_UINT (g_ptr_array_index (source_file_array
, i
));
642 if (file
&& file
!= last_file
) {
643 MonoDebugSourceInfo
*info
= get_source_info (symfile
, file
);
645 g_ptr_array_add (*source_file_list
, info
);
649 (*source_files
) [i
] = (*source_file_list
)->len
- 1;
651 if ((*source_file_list
)->len
== 0 && stm
.file
) {
652 MonoDebugSourceInfo
*info
= get_source_info (symfile
, stm
.file
);
654 g_ptr_array_add (*source_file_list
, info
);
659 g_assert (seq_points
);
661 n
= il_offset_array
->len
;
662 for (i
= 0; i
< il_offset_array
->len
; i
++) {
663 if (GPOINTER_TO_UINT (g_ptr_array_index (hidden_array
, i
))) {
669 *seq_points
= sps
= g_new0 (MonoSymSeqPoint
, n
);
671 for (i
= 0; i
< il_offset_array
->len
; ++i
) {
672 MonoSymSeqPoint
*sp
= &(sps
[j
]);
673 if (!GPOINTER_TO_UINT (g_ptr_array_index (hidden_array
, i
))) {
674 sp
->il_offset
= GPOINTER_TO_UINT (g_ptr_array_index (il_offset_array
, i
));
675 sp
->line
= GPOINTER_TO_UINT (g_ptr_array_index (line_number_array
, i
));
683 if (has_column_info
) {
685 for (i
= 0; i
< il_offset_array
->len
; ++i
) {
686 MonoSymSeqPoint
*sp
= &(sps
[j
]);
687 int column
= read_leb128 (ptr
, &ptr
);
688 if (!GPOINTER_TO_UINT (g_ptr_array_index (hidden_array
, i
))) {
697 for (i
= 0; i
< il_offset_array
->len
; ++i
) {
698 MonoSymSeqPoint
*sp
= &(sps
[j
]);
699 int end_row
, end_column
= -1;
701 end_row
= read_leb128 (ptr
, &ptr
);
702 if (end_row
!= 0xffffff) {
703 end_row
+= GPOINTER_TO_UINT (g_ptr_array_index (line_number_array
, i
));
704 end_column
= read_leb128 (ptr
, &ptr
);
705 if (!GPOINTER_TO_UINT (g_ptr_array_index (hidden_array
, i
))) {
706 sp
->end_line
= end_row
;
707 sp
->end_column
= end_column
;
715 g_ptr_array_free (il_offset_array
, TRUE
);
716 g_ptr_array_free (line_number_array
, TRUE
);
717 g_ptr_array_free (hidden_array
, TRUE
);
719 mono_debugger_unlock ();
724 compare_method (const void *key
, const void *object
)
726 uint32_t token
= GPOINTER_TO_UINT (key
);
727 MonoSymbolFileMethodEntry
*me
= (MonoSymbolFileMethodEntry
*)object
;
729 return token
- read32(&(me
->_token
));
732 MonoDebugMethodInfo
*
733 mono_debug_symfile_lookup_method (MonoDebugHandle
*handle
, MonoMethod
*method
)
735 MonoSymbolFileMethodEntry
*first_ie
, *ie
;
736 MonoDebugMethodInfo
*minfo
;
737 MonoSymbolFile
*symfile
= handle
->symfile
;
739 if (!symfile
->method_hash
)
742 if (handle
->image
!= mono_class_get_image (mono_method_get_class (method
)))
745 mono_debugger_lock ();
747 minfo
= g_hash_table_lookup (symfile
->method_hash
, method
);
749 mono_debugger_unlock ();
753 first_ie
= (MonoSymbolFileMethodEntry
*)
754 (symfile
->raw_contents
+ read32(&(symfile
->offset_table
->_method_table_offset
)));
756 ie
= mono_binary_search (GUINT_TO_POINTER (mono_method_get_token (method
)), first_ie
,
757 read32(&(symfile
->offset_table
->_method_count
)),
758 sizeof (MonoSymbolFileMethodEntry
), compare_method
);
761 mono_debugger_unlock ();
765 minfo
= g_new0 (MonoDebugMethodInfo
, 1);
766 minfo
->index
= (ie
- first_ie
) + 1;
767 minfo
->method
= method
;
768 minfo
->handle
= handle
;
770 minfo
->data_offset
= read32 (&(ie
->_data_offset
));
771 minfo
->lnt_offset
= read32 (&(ie
->_line_number_table
));
773 g_hash_table_insert (symfile
->method_hash
, method
, minfo
);
775 mono_debugger_unlock ();
780 * mono_debug_symfile_lookup_locals:
782 * Return information about the local variables of MINFO from the symbol file.
783 * Return NULL if no information can be found.
784 * The result should be freed using mono_debug_symfile_free_locals ().
787 mono_debug_symfile_lookup_locals (MonoDebugMethodInfo
*minfo
)
789 MonoSymbolFile
*symfile
= minfo
->handle
->symfile
;
791 int i
, len
, locals_offset
, num_locals
, block_index
;
792 int code_block_table_offset
;
793 MonoDebugLocalsInfo
*res
;
798 p
= symfile
->raw_contents
+ minfo
->data_offset
;
800 /* compile_unit_index = */ read_leb128 (p
, &p
);
801 locals_offset
= read_leb128 (p
, &p
);
802 /* namespace_id = */ read_leb128 (p
, &p
);
803 code_block_table_offset
= read_leb128 (p
, &p
);
805 res
= g_new0 (MonoDebugLocalsInfo
, 1);
807 p
= symfile
->raw_contents
+ code_block_table_offset
;
808 res
->num_blocks
= read_leb128 (p
, &p
);
809 res
->code_blocks
= g_new0 (MonoDebugCodeBlock
, res
->num_blocks
);
810 for (i
= 0; i
< res
->num_blocks
; ++i
) {
811 res
->code_blocks
[i
].type
= read_leb128 (p
, &p
);
812 res
->code_blocks
[i
].parent
= read_leb128 (p
, &p
);
813 res
->code_blocks
[i
].start_offset
= read_leb128 (p
, &p
);
814 res
->code_blocks
[i
].end_offset
= read_leb128 (p
, &p
);
817 p
= symfile
->raw_contents
+ locals_offset
;
818 num_locals
= read_leb128 (p
, &p
);
820 res
->num_locals
= num_locals
;
821 res
->locals
= g_new0 (MonoDebugLocalVar
, num_locals
);
823 for (i
= 0; i
< num_locals
; ++i
) {
824 res
->locals
[i
].index
= read_leb128 (p
, &p
);
825 len
= read_leb128 (p
, &p
);
826 res
->locals
[i
].name
= g_malloc (len
+ 1);
827 memcpy (res
->locals
[i
].name
, p
, len
);
828 res
->locals
[i
].name
[len
] = '\0';
830 block_index
= read_leb128 (p
, &p
);
831 if (block_index
>= 1 && block_index
<= res
->num_blocks
)
832 res
->locals
[i
].block
= &res
->code_blocks
[block_index
- 1];