3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010, 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "search_list.h"
31 #include "safe-ctype.h"
34 static int core_num_syms
;
35 static asymbol
**core_syms
;
36 asection
*core_text_sect
;
37 void * core_text_space
;
39 static int min_insn_size
;
42 /* For mapping symbols to specific .o files during file ordering. */
43 struct function_map
* symbol_map
;
44 unsigned int symbol_map_count
;
46 static void read_function_mappings (const char *);
47 static int core_sym_class (asymbol
*);
48 static bfd_boolean get_src_info
49 (bfd_vma
, const char **, const char **, int *);
51 extern void i386_find_call (Sym
*, bfd_vma
, bfd_vma
);
52 extern void alpha_find_call (Sym
*, bfd_vma
, bfd_vma
);
53 extern void vax_find_call (Sym
*, bfd_vma
, bfd_vma
);
54 extern void tahoe_find_call (Sym
*, bfd_vma
, bfd_vma
);
55 extern void sparc_find_call (Sym
*, bfd_vma
, bfd_vma
);
56 extern void mips_find_call (Sym
*, bfd_vma
, bfd_vma
);
57 extern void aarch64_find_call (Sym
*, bfd_vma
, bfd_vma
);
60 parse_error (const char *filename
)
62 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
66 /* Compare two function_map structs based on function name.
67 We want to sort in ascending order. */
70 cmp_symbol_map (const void * l
, const void * r
)
72 return strcmp (((struct function_map
*) l
)->function_name
,
73 ((struct function_map
*) r
)->function_name
);
77 read_function_mappings (const char *filename
)
79 FILE * file
= fopen (filename
, "r");
86 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
90 /* First parse the mapping file so we know how big we need to
91 make our tables. We also do some sanity checks at this
97 matches
= fscanf (file
, "%[^\n:]", dummy
);
99 parse_error (filename
);
101 /* Just skip messages about files with no symbols. */
102 if (!strncmp (dummy
, "No symbols in ", 14))
104 matches
= fscanf (file
, "\n");
106 parse_error (filename
);
110 /* Don't care what else is on this line at this point. */
111 matches
= fscanf (file
, "%[^\n]\n", dummy
);
113 parse_error (filename
);
117 /* Now we know how big we need to make our table. */
118 symbol_map
= ((struct function_map
*)
119 xmalloc (count
* sizeof (struct function_map
)));
121 /* Rewind the input file so we can read it again. */
124 /* Read each entry and put it into the table. */
131 matches
= fscanf (file
, "%[^\n:]", dummy
);
133 parse_error (filename
);
135 /* Just skip messages about files with no symbols. */
136 if (!strncmp (dummy
, "No symbols in ", 14))
138 matches
= fscanf (file
, "\n");
140 parse_error (filename
);
144 /* dummy has the filename, go ahead and copy it. */
145 symbol_map
[count
].file_name
= (char *) xmalloc (strlen (dummy
) + 1);
146 strcpy (symbol_map
[count
].file_name
, dummy
);
148 /* Now we need the function name. */
149 matches
= fscanf (file
, "%[^\n]\n", dummy
);
151 parse_error (filename
);
152 tmp
= strrchr (dummy
, ' ') + 1;
153 symbol_map
[count
].function_name
= (char *) xmalloc (strlen (tmp
) + 1);
154 strcpy (symbol_map
[count
].function_name
, tmp
);
158 /* Record the size of the map table for future reference. */
159 symbol_map_count
= count
;
161 for (i
= 0; i
< symbol_map_count
; ++i
)
163 || filename_cmp (symbol_map
[i
].file_name
, symbol_map
[i
- 1].file_name
))
164 symbol_map
[i
].is_first
= 1;
166 qsort (symbol_map
, symbol_map_count
, sizeof (struct function_map
), cmp_symbol_map
);
170 core_init (const char * aout_name
)
176 core_bfd
= bfd_openr (aout_name
, 0);
184 if (!bfd_check_format (core_bfd
, bfd_object
))
186 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
190 /* Get core's text section. */
191 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
194 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
197 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
203 /* Read core's symbol table. */
205 /* This will probably give us more than we need, but that's ok. */
206 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
207 if (core_sym_bytes
< 0)
209 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
210 bfd_errmsg (bfd_get_error ()));
214 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
215 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
217 if (core_num_syms
< 0)
219 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
220 bfd_errmsg (bfd_get_error ()));
224 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
225 0, NULL
, &synthsyms
);
232 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
233 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
234 symp
= core_syms
+ core_num_syms
;
235 core_num_syms
+= synth_count
;
236 for (i
= 0; i
< synth_count
; i
++)
237 *symp
++ = synthsyms
+ i
;
244 switch (bfd_get_arch (core_bfd
))
259 if (function_mapping_file
)
260 read_function_mappings (function_mapping_file
);
263 /* Read in the text space of an a.out file. */
266 core_get_text_space (bfd
*cbfd
)
268 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
270 if (!core_text_space
)
272 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
273 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
277 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
278 0, bfd_get_section_size (core_text_sect
)))
280 bfd_perror ("bfd_get_section_contents");
281 free (core_text_space
);
285 if (!core_text_space
)
286 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
291 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
293 if (core_text_space
== 0)
296 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
298 switch (bfd_get_arch (core_bfd
))
301 i386_find_call (parent
, p_lowpc
, p_highpc
);
305 alpha_find_call (parent
, p_lowpc
, p_highpc
);
309 vax_find_call (parent
, p_lowpc
, p_highpc
);
313 sparc_find_call (parent
, p_lowpc
, p_highpc
);
317 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
321 mips_find_call (parent
, p_lowpc
, p_highpc
);
324 case bfd_arch_aarch64
:
325 aarch64_find_call (parent
, p_lowpc
, p_highpc
);
329 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
330 whoami
, bfd_printable_name(core_bfd
));
332 /* Don't give the error more than once. */
333 ignore_direct_calls
= FALSE
;
337 /* Return class of symbol SYM. The returned class can be any of:
338 0 -> symbol is not interesting to us
339 'T' -> symbol is a global name
340 't' -> symbol is a local (static) name. */
343 core_sym_class (asymbol
*sym
)
350 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
353 /* Must be a text symbol, and static text symbols
354 don't qualify if ignore_static_funcs set. */
355 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
357 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
362 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
366 return i
; /* It's a global symbol. */
369 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
370 also be a data symbol. */
375 /* Not a static text symbol. */
376 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
381 /* Do some more filtering on static function-names. */
382 if (ignore_static_funcs
)
385 /* Can't zero-length name or funny characters in name, where
386 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
387 if (!sym
->name
|| sym
->name
[0] == '\0')
390 for (name
= sym
->name
; *name
; ++name
)
397 /* Allow both nested subprograms (which end with ".NNN", where N is
398 a digit) and GCC cloned functions (which contain ".clone").
399 Allow for multiple iterations of both - apparently GCC can clone
400 clones and subprograms. */
402 #define CLONE_NAME ".clone."
403 #define CLONE_NAME_LEN strlen (CLONE_NAME)
404 #define CONSTPROP_NAME ".constprop."
405 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME)
407 if (strlen (name
) > CLONE_NAME_LEN
408 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
409 name
+= CLONE_NAME_LEN
- 1;
411 else if (strlen (name
) > CONSTPROP_NAME_LEN
412 && strncmp (name
, CONSTPROP_NAME
, CONSTPROP_NAME_LEN
) == 0)
413 name
+= CONSTPROP_NAME_LEN
- 1;
415 for (name
++; *name
; name
++)
416 if (digit_seen
&& *name
== '.')
418 else if (ISDIGIT (*name
))
425 /* On systems where the C compiler adds an underscore to all
426 names, static names without underscores seem usually to be
427 labels in hand written assembler in the library. We don't want
428 these names. This is certainly necessary on a Sparc running
429 SunOS 4.1 (try profiling a program that does a lot of
430 division). I don't know whether it has harmful side effects on
431 other systems. Perhaps it should be made configurable. */
432 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
434 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
435 /* GCC may add special symbols to help gdb figure out the file
436 language. We want to ignore these, since sometimes they mask
437 the real function. (dj@ctron) */
438 || !strncmp (sym
->name
, "__gnu_compiled", 14)
439 || !strncmp (sym
->name
, "___gnu_compiled", 15))
444 /* If the object file supports marking of function symbols, then
445 we can zap anything that doesn't have BSF_FUNCTION set. */
446 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
449 return 't'; /* It's a static text symbol. */
452 /* Get whatever source info we can get regarding address ADDR. */
455 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
457 const char *fname
= 0, *func_name
= 0;
460 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
461 addr
- core_text_sect
->vma
,
462 &fname
, &func_name
, (unsigned int *) &l
)
463 && fname
&& func_name
&& l
)
465 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
466 (unsigned long) addr
, fname
, l
, func_name
));
474 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
475 (unsigned long) addr
,
476 fname
? fname
: "<unknown>", l
,
477 func_name
? func_name
: "<unknown>"));
482 /* Return number of symbols in a symbol-table file. */
485 num_of_syms_in (FILE * f
)
487 const int BUFSIZE
= 1024;
488 char * buf
= (char *) xmalloc (BUFSIZE
);
489 char * address
= (char *) xmalloc (BUFSIZE
);
491 char * name
= (char *) xmalloc (BUFSIZE
);
494 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
496 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
497 if (type
== 't' || type
== 'T')
508 /* Read symbol table from a file. */
511 core_create_syms_from (const char * sym_table_file
)
513 const int BUFSIZE
= 1024;
514 char * buf
= (char *) xmalloc (BUFSIZE
);
515 char * address
= (char *) xmalloc (BUFSIZE
);
517 char * name
= (char *) xmalloc (BUFSIZE
);
518 bfd_vma min_vma
= ~(bfd_vma
) 0;
522 f
= fopen (sym_table_file
, "r");
525 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
529 /* Pass 1 - determine upper bound on number of function names. */
530 symtab
.len
= num_of_syms_in (f
);
534 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
538 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
540 /* Pass 2 - create symbols. */
541 symtab
.limit
= symtab
.base
;
543 if (fseek (f
, 0, SEEK_SET
) != 0)
545 perror (sym_table_file
);
549 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
551 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
552 if (type
!= 't' && type
!= 'T')
555 sym_init (symtab
.limit
);
557 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
559 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
560 strcpy ((char *) symtab
.limit
->name
, name
);
561 symtab
.limit
->mapped
= 0;
562 symtab
.limit
->is_func
= TRUE
;
563 symtab
.limit
->is_bb_head
= TRUE
;
564 symtab
.limit
->is_static
= (type
== 't');
565 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
566 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
572 symtab
.len
= symtab
.limit
- symtab
.base
;
573 symtab_finalize (&symtab
);
581 search_mapped_symbol (const void * l
, const void * r
)
583 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
586 /* Read in symbol table from core.
587 One symbol per function is entered. */
590 core_create_function_syms (void)
592 bfd_vma min_vma
= ~ (bfd_vma
) 0;
596 struct function_map
* found
= NULL
;
597 int core_has_func_syms
= 0;
599 switch (core_bfd
->xvec
->flavour
)
603 case bfd_target_coff_flavour
:
604 case bfd_target_ecoff_flavour
:
605 case bfd_target_xcoff_flavour
:
606 case bfd_target_elf_flavour
:
607 case bfd_target_nlm_flavour
:
608 case bfd_target_som_flavour
:
609 core_has_func_syms
= 1;
612 /* Pass 1 - determine upper bound on number of function names. */
615 for (i
= 0; i
< core_num_syms
; ++i
)
617 if (!core_sym_class (core_syms
[i
]))
620 /* Don't create a symtab entry for a function that has
621 a mapping to a file, unless it's the first function
623 if (symbol_map_count
!= 0)
625 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
627 found
= (struct function_map
*) bsearch
628 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
629 sizeof (struct function_map
), search_mapped_symbol
);
631 if (found
== NULL
|| found
->is_first
)
637 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
641 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
643 /* Pass 2 - create symbols. */
644 symtab
.limit
= symtab
.base
;
646 for (i
= 0; i
< core_num_syms
; ++i
)
650 cxxclass
= core_sym_class (core_syms
[i
]);
655 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
656 (unsigned long) core_syms
[i
]->value
,
657 core_syms
[i
]->name
));
661 if (symbol_map_count
!= 0)
663 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
665 found
= (struct function_map
*) bsearch
666 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
667 sizeof (struct function_map
), search_mapped_symbol
);
669 if (found
&& ! found
->is_first
)
672 sym_init (symtab
.limit
);
674 /* Symbol offsets are always section-relative. */
675 sym_sec
= core_syms
[i
]->section
;
676 symtab
.limit
->addr
= core_syms
[i
]->value
;
678 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
682 symtab
.limit
->name
= found
->file_name
;
683 symtab
.limit
->mapped
= 1;
687 symtab
.limit
->name
= core_syms
[i
]->name
;
688 symtab
.limit
->mapped
= 0;
691 /* Lookup filename and line number, if we can. */
693 const char * filename
;
694 const char * func_name
;
696 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
697 & symtab
.limit
->line_num
))
699 symtab
.limit
->file
= source_file_lookup_path (filename
);
701 /* FIXME: Checking __osf__ here does not work with a cross
704 /* Suppress symbols that are not function names. This is
705 useful to suppress code-labels and aliases.
707 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
708 labels do not appear in the symbol table info, so this isn't
711 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
713 /* The symbol's address maps to a different name, so
714 it can't be a function-entry point. This happens
715 for labels, for example. */
717 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
718 symtab
.limit
->name
, func_name
));
725 symtab
.limit
->is_func
= (!core_has_func_syms
726 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
727 symtab
.limit
->is_bb_head
= TRUE
;
730 symtab
.limit
->is_static
= TRUE
;
732 /* Keep track of the minimum and maximum vma addresses used by all
733 symbols. When computing the max_vma, use the ending address of the
734 section containing the symbol, if available. */
735 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
737 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
738 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
741 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
743 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
744 (long) (symtab
.limit
- symtab
.base
),
746 (unsigned long) symtab
.limit
->addr
));
750 symtab
.len
= symtab
.limit
- symtab
.base
;
751 symtab_finalize (&symtab
);
754 /* Read in symbol table from core.
755 One symbol per line of source code is entered. */
758 core_create_line_syms (void)
760 char *prev_name
, *prev_filename
;
761 unsigned int prev_name_len
, prev_filename_len
;
762 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
763 Sym
*prev
, dummy
, *sym
;
764 const char *filename
;
769 /* Create symbols for functions as usual. This is necessary in
770 cases where parts of a program were not compiled with -g. For
771 those parts we still want to get info at the function level. */
772 core_create_function_syms ();
774 /* Pass 1: count the number of symbols. */
776 /* To find all line information, walk through all possible
777 text-space addresses (one by one!) and get the debugging
778 info for each address. When the debugging info changes,
779 it is time to create a new symbol.
781 Of course, this is rather slow and it would be better if
782 BFD would provide an iterator for enumerating all line infos. */
783 prev_name_len
= PATH_MAX
;
784 prev_filename_len
= PATH_MAX
;
785 prev_name
= (char *) xmalloc (prev_name_len
);
786 prev_filename
= (char *) xmalloc (prev_filename_len
);
790 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
791 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
795 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
796 || (prev_line_num
== dummy
.line_num
798 && strcmp (prev_name
, dummy
.name
) == 0
799 && filename_cmp (prev_filename
, filename
) == 0))
803 prev_line_num
= dummy
.line_num
;
805 len
= strlen (dummy
.name
);
806 if (len
>= prev_name_len
)
808 prev_name_len
= len
+ 1024;
810 prev_name
= (char *) xmalloc (prev_name_len
);
813 strcpy (prev_name
, dummy
.name
);
814 len
= strlen (filename
);
816 if (len
>= prev_filename_len
)
818 prev_filename_len
= len
+ 1024;
819 free (prev_filename
);
820 prev_filename
= (char *) xmalloc (prev_filename_len
);
823 strcpy (prev_filename
, filename
);
825 min_vma
= MIN (vma
, min_vma
);
826 max_vma
= MAX (vma
, max_vma
);
830 free (prev_filename
);
832 /* Make room for function symbols, too. */
833 ltab
.len
+= symtab
.len
;
834 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
835 ltab
.limit
= ltab
.base
;
837 /* Pass 2 - create symbols. */
839 /* We now set is_static as we go along, rather than by running
840 through the symbol table at the end.
842 The old way called symtab_finalize before the is_static pass,
843 causing a problem since symtab_finalize uses is_static as part of
844 its address conflict resolution algorithm. Since global symbols
845 were prefered over static symbols, and all line symbols were
846 global at that point, static function names that conflicted with
847 their own line numbers (static, but labeled as global) were
848 rejected in favor of the line num.
850 This was not the desired functionality. We always want to keep
851 our function symbols and discard any conflicting line symbols.
852 Perhaps symtab_finalize should be modified to make this
853 distinction as well, but the current fix works and the code is a
857 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
859 sym_init (ltab
.limit
);
861 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
862 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
863 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
864 && filename_cmp (prev
->file
->name
, filename
) == 0))
867 /* Make name pointer a malloc'ed string. */
868 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
869 ltab
.limit
->file
= source_file_lookup_path (filename
);
871 ltab
.limit
->addr
= vma
;
873 /* Set is_static based on the enclosing function, using either:
874 1) the previous symbol, if it's from the same function, or
875 2) a symtab lookup. */
876 if (prev
&& ltab
.limit
->file
== prev
->file
&&
877 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
879 ltab
.limit
->is_static
= prev
->is_static
;
883 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
885 ltab
.limit
->is_static
= sym
->is_static
;
890 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
891 (unsigned long) (ltab
.limit
- ltab
.base
),
893 (unsigned long) ltab
.limit
->addr
));
897 /* Copy in function symbols. */
898 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
899 ltab
.limit
+= symtab
.len
;
901 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
904 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
905 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
909 /* Finalize ltab and make it symbol table. */
910 symtab_finalize (<ab
);
This page took 0.051383 seconds and 4 git commands to generate.