3 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
4 2010, 2011 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
);
59 parse_error (const char *filename
)
61 fprintf (stderr
, _("%s: unable to parse mapping file %s.\n"), whoami
, filename
);
65 /* Compare two function_map structs based on function name.
66 We want to sort in ascending order. */
69 cmp_symbol_map (const void * l
, const void * r
)
71 return strcmp (((struct function_map
*) l
)->function_name
,
72 ((struct function_map
*) r
)->function_name
);
76 read_function_mappings (const char *filename
)
78 FILE * file
= fopen (filename
, "r");
85 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, filename
);
89 /* First parse the mapping file so we know how big we need to
90 make our tables. We also do some sanity checks at this
96 matches
= fscanf (file
, "%[^\n:]", dummy
);
98 parse_error (filename
);
100 /* Just skip messages about files with no symbols. */
101 if (!strncmp (dummy
, "No symbols in ", 14))
103 matches
= fscanf (file
, "\n");
105 parse_error (filename
);
109 /* Don't care what else is on this line at this point. */
110 matches
= fscanf (file
, "%[^\n]\n", dummy
);
112 parse_error (filename
);
116 /* Now we know how big we need to make our table. */
117 symbol_map
= ((struct function_map
*)
118 xmalloc (count
* sizeof (struct function_map
)));
120 /* Rewind the input file so we can read it again. */
123 /* Read each entry and put it into the table. */
130 matches
= fscanf (file
, "%[^\n:]", dummy
);
132 parse_error (filename
);
134 /* Just skip messages about files with no symbols. */
135 if (!strncmp (dummy
, "No symbols in ", 14))
137 matches
= fscanf (file
, "\n");
139 parse_error (filename
);
143 /* dummy has the filename, go ahead and copy it. */
144 symbol_map
[count
].file_name
= (char *) xmalloc (strlen (dummy
) + 1);
145 strcpy (symbol_map
[count
].file_name
, dummy
);
147 /* Now we need the function name. */
148 matches
= fscanf (file
, "%[^\n]\n", dummy
);
150 parse_error (filename
);
151 tmp
= strrchr (dummy
, ' ') + 1;
152 symbol_map
[count
].function_name
= (char *) xmalloc (strlen (tmp
) + 1);
153 strcpy (symbol_map
[count
].function_name
, tmp
);
157 /* Record the size of the map table for future reference. */
158 symbol_map_count
= count
;
160 for (i
= 0; i
< symbol_map_count
; ++i
)
162 || filename_cmp (symbol_map
[i
].file_name
, symbol_map
[i
- 1].file_name
))
163 symbol_map
[i
].is_first
= 1;
165 qsort (symbol_map
, symbol_map_count
, sizeof (struct function_map
), cmp_symbol_map
);
169 core_init (const char * aout_name
)
175 core_bfd
= bfd_openr (aout_name
, 0);
183 if (!bfd_check_format (core_bfd
, bfd_object
))
185 fprintf (stderr
, _("%s: %s: not in executable format\n"), whoami
, aout_name
);
189 /* Get core's text section. */
190 core_text_sect
= bfd_get_section_by_name (core_bfd
, ".text");
193 core_text_sect
= bfd_get_section_by_name (core_bfd
, "$CODE$");
196 fprintf (stderr
, _("%s: can't find .text section in %s\n"),
202 /* Read core's symbol table. */
204 /* This will probably give us more than we need, but that's ok. */
205 core_sym_bytes
= bfd_get_symtab_upper_bound (core_bfd
);
206 if (core_sym_bytes
< 0)
208 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
209 bfd_errmsg (bfd_get_error ()));
213 core_syms
= (asymbol
**) xmalloc (core_sym_bytes
);
214 core_num_syms
= bfd_canonicalize_symtab (core_bfd
, core_syms
);
216 if (core_num_syms
< 0)
218 fprintf (stderr
, "%s: %s: %s\n", whoami
, aout_name
,
219 bfd_errmsg (bfd_get_error ()));
223 synth_count
= bfd_get_synthetic_symtab (core_bfd
, core_num_syms
, core_syms
,
224 0, NULL
, &synthsyms
);
231 new_size
= (core_num_syms
+ synth_count
+ 1) * sizeof (*core_syms
);
232 core_syms
= (asymbol
**) xrealloc (core_syms
, new_size
);
233 symp
= core_syms
+ core_num_syms
;
234 core_num_syms
+= synth_count
;
235 for (i
= 0; i
< synth_count
; i
++)
236 *symp
++ = synthsyms
+ i
;
243 switch (bfd_get_arch (core_bfd
))
258 if (function_mapping_file
)
259 read_function_mappings (function_mapping_file
);
262 /* Read in the text space of an a.out file. */
265 core_get_text_space (bfd
*cbfd
)
267 core_text_space
= malloc (bfd_get_section_size (core_text_sect
));
269 if (!core_text_space
)
271 fprintf (stderr
, _("%s: ran out room for %lu bytes of text space\n"),
272 whoami
, (unsigned long) bfd_get_section_size (core_text_sect
));
276 if (!bfd_get_section_contents (cbfd
, core_text_sect
, core_text_space
,
277 0, bfd_get_section_size (core_text_sect
)))
279 bfd_perror ("bfd_get_section_contents");
280 free (core_text_space
);
284 if (!core_text_space
)
285 fprintf (stderr
, _("%s: can't do -c\n"), whoami
);
290 find_call (Sym
*parent
, bfd_vma p_lowpc
, bfd_vma p_highpc
)
292 if (core_text_space
== 0)
295 hist_clip_symbol_address (&p_lowpc
, &p_highpc
);
297 switch (bfd_get_arch (core_bfd
))
300 i386_find_call (parent
, p_lowpc
, p_highpc
);
304 alpha_find_call (parent
, p_lowpc
, p_highpc
);
308 vax_find_call (parent
, p_lowpc
, p_highpc
);
312 sparc_find_call (parent
, p_lowpc
, p_highpc
);
316 tahoe_find_call (parent
, p_lowpc
, p_highpc
);
320 mips_find_call (parent
, p_lowpc
, p_highpc
);
324 fprintf (stderr
, _("%s: -c not supported on architecture %s\n"),
325 whoami
, bfd_printable_name(core_bfd
));
327 /* Don't give the error more than once. */
328 ignore_direct_calls
= FALSE
;
332 /* Return class of symbol SYM. The returned class can be any of:
333 0 -> symbol is not interesting to us
334 'T' -> symbol is a global name
335 't' -> symbol is a local (static) name. */
338 core_sym_class (asymbol
*sym
)
345 if (sym
->section
== NULL
|| (sym
->flags
& BSF_DEBUGGING
) != 0)
348 /* Must be a text symbol, and static text symbols
349 don't qualify if ignore_static_funcs set. */
350 if (ignore_static_funcs
&& (sym
->flags
& BSF_LOCAL
))
352 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s: not a function\n",
357 bfd_get_symbol_info (core_bfd
, sym
, &syminfo
);
361 return i
; /* It's a global symbol. */
364 /* Treat weak symbols as text symbols. FIXME: a weak symbol may
365 also be a data symbol. */
370 /* Not a static text symbol. */
371 DBG (AOUTDEBUG
, printf ("[core_sym_class] %s is of class %c\n",
376 /* Do some more filtering on static function-names. */
377 if (ignore_static_funcs
)
380 /* Can't zero-length name or funny characters in name, where
381 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */
382 if (!sym
->name
|| sym
->name
[0] == '\0')
385 for (name
= sym
->name
; *name
; ++name
)
392 /* Allow both nested subprograms (which end with ".NNN", where N is
393 a digit) and GCC cloned functions (which contain ".clone").
394 Allow for multiple iterations of both - apparently GCC can clone
395 clones and subprograms. */
397 #define CLONE_NAME ".clone."
398 #define CLONE_NAME_LEN strlen (CLONE_NAME)
400 if (strlen (name
) > CLONE_NAME_LEN
401 && strncmp (name
, CLONE_NAME
, CLONE_NAME_LEN
) == 0)
402 name
+= CLONE_NAME_LEN
- 1;
404 for (name
++; *name
; name
++)
405 if (digit_seen
&& *name
== '.')
407 else if (ISDIGIT (*name
))
414 /* On systems where the C compiler adds an underscore to all
415 names, static names without underscores seem usually to be
416 labels in hand written assembler in the library. We don't want
417 these names. This is certainly necessary on a Sparc running
418 SunOS 4.1 (try profiling a program that does a lot of
419 division). I don't know whether it has harmful side effects on
420 other systems. Perhaps it should be made configurable. */
421 sym_prefix
= bfd_get_symbol_leading_char (core_bfd
);
423 if ((sym_prefix
&& sym_prefix
!= sym
->name
[0])
424 /* GCC may add special symbols to help gdb figure out the file
425 language. We want to ignore these, since sometimes they mask
426 the real function. (dj@ctron) */
427 || !strncmp (sym
->name
, "__gnu_compiled", 14)
428 || !strncmp (sym
->name
, "___gnu_compiled", 15))
433 /* If the object file supports marking of function symbols, then
434 we can zap anything that doesn't have BSF_FUNCTION set. */
435 if (ignore_non_functions
&& (sym
->flags
& BSF_FUNCTION
) == 0)
438 return 't'; /* It's a static text symbol. */
441 /* Get whatever source info we can get regarding address ADDR. */
444 get_src_info (bfd_vma addr
, const char **filename
, const char **name
, int *line_num
)
446 const char *fname
= 0, *func_name
= 0;
449 if (bfd_find_nearest_line (core_bfd
, core_text_sect
, core_syms
,
450 addr
- core_text_sect
->vma
,
451 &fname
, &func_name
, (unsigned int *) &l
)
452 && fname
&& func_name
&& l
)
454 DBG (AOUTDEBUG
, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
455 (unsigned long) addr
, fname
, l
, func_name
));
463 DBG (AOUTDEBUG
, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
464 (unsigned long) addr
,
465 fname
? fname
: "<unknown>", l
,
466 func_name
? func_name
: "<unknown>"));
471 /* Return number of symbols in a symbol-table file. */
474 num_of_syms_in (FILE * f
)
476 const int BUFSIZE
= 1024;
477 char * buf
= (char *) xmalloc (BUFSIZE
);
478 char * address
= (char *) xmalloc (BUFSIZE
);
480 char * name
= (char *) xmalloc (BUFSIZE
);
483 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
485 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
486 if (type
== 't' || type
== 'T')
497 /* Read symbol table from a file. */
500 core_create_syms_from (const char * sym_table_file
)
502 const int BUFSIZE
= 1024;
503 char * buf
= (char *) xmalloc (BUFSIZE
);
504 char * address
= (char *) xmalloc (BUFSIZE
);
506 char * name
= (char *) xmalloc (BUFSIZE
);
507 bfd_vma min_vma
= ~(bfd_vma
) 0;
511 f
= fopen (sym_table_file
, "r");
514 fprintf (stderr
, _("%s: could not open %s.\n"), whoami
, sym_table_file
);
518 /* Pass 1 - determine upper bound on number of function names. */
519 symtab
.len
= num_of_syms_in (f
);
523 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, sym_table_file
);
527 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
529 /* Pass 2 - create symbols. */
530 symtab
.limit
= symtab
.base
;
532 if (fseek (f
, 0, SEEK_SET
) != 0)
534 perror (sym_table_file
);
538 while (!feof (f
) && fgets (buf
, BUFSIZE
- 1, f
))
540 if (sscanf (buf
, "%s %c %s", address
, &type
, name
) == 3)
541 if (type
!= 't' && type
!= 'T')
544 sym_init (symtab
.limit
);
546 sscanf (address
, "%" BFD_VMA_FMT
"x", &(symtab
.limit
->addr
) );
548 symtab
.limit
->name
= (char *) xmalloc (strlen (name
) + 1);
549 strcpy ((char *) symtab
.limit
->name
, name
);
550 symtab
.limit
->mapped
= 0;
551 symtab
.limit
->is_func
= TRUE
;
552 symtab
.limit
->is_bb_head
= TRUE
;
553 symtab
.limit
->is_static
= (type
== 't');
554 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
555 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
561 symtab
.len
= symtab
.limit
- symtab
.base
;
562 symtab_finalize (&symtab
);
570 search_mapped_symbol (const void * l
, const void * r
)
572 return strcmp ((const char *) l
, ((const struct function_map
*) r
)->function_name
);
575 /* Read in symbol table from core.
576 One symbol per function is entered. */
579 core_create_function_syms (void)
581 bfd_vma min_vma
= ~ (bfd_vma
) 0;
585 struct function_map
* found
= NULL
;
586 int core_has_func_syms
= 0;
588 switch (core_bfd
->xvec
->flavour
)
592 case bfd_target_coff_flavour
:
593 case bfd_target_ecoff_flavour
:
594 case bfd_target_xcoff_flavour
:
595 case bfd_target_elf_flavour
:
596 case bfd_target_nlm_flavour
:
597 case bfd_target_som_flavour
:
598 core_has_func_syms
= 1;
601 /* Pass 1 - determine upper bound on number of function names. */
604 for (i
= 0; i
< core_num_syms
; ++i
)
606 if (!core_sym_class (core_syms
[i
]))
609 /* Don't create a symtab entry for a function that has
610 a mapping to a file, unless it's the first function
612 if (symbol_map_count
!= 0)
614 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
616 found
= (struct function_map
*) bsearch
617 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
618 sizeof (struct function_map
), search_mapped_symbol
);
620 if (found
== NULL
|| found
->is_first
)
626 fprintf (stderr
, _("%s: file `%s' has no symbols\n"), whoami
, a_out_name
);
630 symtab
.base
= (Sym
*) xmalloc (symtab
.len
* sizeof (Sym
));
632 /* Pass 2 - create symbols. */
633 symtab
.limit
= symtab
.base
;
635 for (i
= 0; i
< core_num_syms
; ++i
)
639 cxxclass
= core_sym_class (core_syms
[i
]);
644 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
645 (unsigned long) core_syms
[i
]->value
,
646 core_syms
[i
]->name
));
650 if (symbol_map_count
!= 0)
652 /* Note: some systems (SunOS 5.8) crash if bsearch base argument
654 found
= (struct function_map
*) bsearch
655 (core_syms
[i
]->name
, symbol_map
, symbol_map_count
,
656 sizeof (struct function_map
), search_mapped_symbol
);
658 if (found
&& ! found
->is_first
)
661 sym_init (symtab
.limit
);
663 /* Symbol offsets are always section-relative. */
664 sym_sec
= core_syms
[i
]->section
;
665 symtab
.limit
->addr
= core_syms
[i
]->value
;
667 symtab
.limit
->addr
+= bfd_get_section_vma (sym_sec
->owner
, sym_sec
);
671 symtab
.limit
->name
= found
->file_name
;
672 symtab
.limit
->mapped
= 1;
676 symtab
.limit
->name
= core_syms
[i
]->name
;
677 symtab
.limit
->mapped
= 0;
680 /* Lookup filename and line number, if we can. */
682 const char * filename
;
683 const char * func_name
;
685 if (get_src_info (symtab
.limit
->addr
, & filename
, & func_name
,
686 & symtab
.limit
->line_num
))
688 symtab
.limit
->file
= source_file_lookup_path (filename
);
690 /* FIXME: Checking __osf__ here does not work with a cross
693 /* Suppress symbols that are not function names. This is
694 useful to suppress code-labels and aliases.
696 This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
697 labels do not appear in the symbol table info, so this isn't
700 if (strcmp (symtab
.limit
->name
, func_name
) != 0)
702 /* The symbol's address maps to a different name, so
703 it can't be a function-entry point. This happens
704 for labels, for example. */
706 printf ("[core_create_function_syms: rej %s (maps to %s)\n",
707 symtab
.limit
->name
, func_name
));
714 symtab
.limit
->is_func
= (!core_has_func_syms
715 || (core_syms
[i
]->flags
& BSF_FUNCTION
) != 0);
716 symtab
.limit
->is_bb_head
= TRUE
;
719 symtab
.limit
->is_static
= TRUE
;
721 /* Keep track of the minimum and maximum vma addresses used by all
722 symbols. When computing the max_vma, use the ending address of the
723 section containing the symbol, if available. */
724 min_vma
= MIN (symtab
.limit
->addr
, min_vma
);
726 max_vma
= MAX (bfd_get_section_vma (sym_sec
->owner
, sym_sec
)
727 + bfd_section_size (sym_sec
->owner
, sym_sec
) - 1,
730 max_vma
= MAX (symtab
.limit
->addr
, max_vma
);
732 DBG (AOUTDEBUG
, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
733 (long) (symtab
.limit
- symtab
.base
),
735 (unsigned long) symtab
.limit
->addr
));
739 symtab
.len
= symtab
.limit
- symtab
.base
;
740 symtab_finalize (&symtab
);
743 /* Read in symbol table from core.
744 One symbol per line of source code is entered. */
747 core_create_line_syms (void)
749 char *prev_name
, *prev_filename
;
750 unsigned int prev_name_len
, prev_filename_len
;
751 bfd_vma vma
, min_vma
= ~(bfd_vma
) 0, max_vma
= 0;
752 Sym
*prev
, dummy
, *sym
;
753 const char *filename
;
758 /* Create symbols for functions as usual. This is necessary in
759 cases where parts of a program were not compiled with -g. For
760 those parts we still want to get info at the function level. */
761 core_create_function_syms ();
763 /* Pass 1: count the number of symbols. */
765 /* To find all line information, walk through all possible
766 text-space addresses (one by one!) and get the debugging
767 info for each address. When the debugging info changes,
768 it is time to create a new symbol.
770 Of course, this is rather slow and it would be better if
771 BFD would provide an iterator for enumerating all line infos. */
772 prev_name_len
= PATH_MAX
;
773 prev_filename_len
= PATH_MAX
;
774 prev_name
= (char *) xmalloc (prev_name_len
);
775 prev_filename
= (char *) xmalloc (prev_filename_len
);
779 vma_high
= core_text_sect
->vma
+ bfd_get_section_size (core_text_sect
);
780 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
784 if (!get_src_info (vma
, &filename
, &dummy
.name
, &dummy
.line_num
)
785 || (prev_line_num
== dummy
.line_num
787 && strcmp (prev_name
, dummy
.name
) == 0
788 && filename_cmp (prev_filename
, filename
) == 0))
792 prev_line_num
= dummy
.line_num
;
794 len
= strlen (dummy
.name
);
795 if (len
>= prev_name_len
)
797 prev_name_len
= len
+ 1024;
799 prev_name
= (char *) xmalloc (prev_name_len
);
802 strcpy (prev_name
, dummy
.name
);
803 len
= strlen (filename
);
805 if (len
>= prev_filename_len
)
807 prev_filename_len
= len
+ 1024;
808 free (prev_filename
);
809 prev_filename
= (char *) xmalloc (prev_filename_len
);
812 strcpy (prev_filename
, filename
);
814 min_vma
= MIN (vma
, min_vma
);
815 max_vma
= MAX (vma
, max_vma
);
819 free (prev_filename
);
821 /* Make room for function symbols, too. */
822 ltab
.len
+= symtab
.len
;
823 ltab
.base
= (Sym
*) xmalloc (ltab
.len
* sizeof (Sym
));
824 ltab
.limit
= ltab
.base
;
826 /* Pass 2 - create symbols. */
828 /* We now set is_static as we go along, rather than by running
829 through the symbol table at the end.
831 The old way called symtab_finalize before the is_static pass,
832 causing a problem since symtab_finalize uses is_static as part of
833 its address conflict resolution algorithm. Since global symbols
834 were prefered over static symbols, and all line symbols were
835 global at that point, static function names that conflicted with
836 their own line numbers (static, but labeled as global) were
837 rejected in favor of the line num.
839 This was not the desired functionality. We always want to keep
840 our function symbols and discard any conflicting line symbols.
841 Perhaps symtab_finalize should be modified to make this
842 distinction as well, but the current fix works and the code is a
846 for (vma
= core_text_sect
->vma
; vma
< vma_high
; vma
+= min_insn_size
)
848 sym_init (ltab
.limit
);
850 if (!get_src_info (vma
, &filename
, <ab
.limit
->name
, <ab
.limit
->line_num
)
851 || (prev
&& prev
->line_num
== ltab
.limit
->line_num
852 && strcmp (prev
->name
, ltab
.limit
->name
) == 0
853 && filename_cmp (prev
->file
->name
, filename
) == 0))
856 /* Make name pointer a malloc'ed string. */
857 ltab
.limit
->name
= xstrdup (ltab
.limit
->name
);
858 ltab
.limit
->file
= source_file_lookup_path (filename
);
860 ltab
.limit
->addr
= vma
;
862 /* Set is_static based on the enclosing function, using either:
863 1) the previous symbol, if it's from the same function, or
864 2) a symtab lookup. */
865 if (prev
&& ltab
.limit
->file
== prev
->file
&&
866 strcmp (ltab
.limit
->name
, prev
->name
) == 0)
868 ltab
.limit
->is_static
= prev
->is_static
;
872 sym
= sym_lookup(&symtab
, ltab
.limit
->addr
);
874 ltab
.limit
->is_static
= sym
->is_static
;
879 DBG (AOUTDEBUG
, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
880 (unsigned long) (ltab
.limit
- ltab
.base
),
882 (unsigned long) ltab
.limit
->addr
));
886 /* Copy in function symbols. */
887 memcpy (ltab
.limit
, symtab
.base
, symtab
.len
* sizeof (Sym
));
888 ltab
.limit
+= symtab
.len
;
890 if ((unsigned int) (ltab
.limit
- ltab
.base
) != ltab
.len
)
893 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
894 whoami
, ltab
.len
, (long) (ltab
.limit
- ltab
.base
));
898 /* Finalize ltab and make it symbol table. */
899 symtab_finalize (<ab
);
This page took 0.04765 seconds and 4 git commands to generate.