trunk/src/symbol.c

/*
 *  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: symbol.c,v 1.38 2007/04/22 14:32:01 debug Exp $
 *
 *  Address to symbol translation routines.
 *
 *  This module is (probably) independent from the rest of the emulator.
 *  symbol_init() must be called before any other function in this file is used.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "symbol.h"


#define SYMBOLBUF_MAX   100


/*
 *  symbol_nsymbols():
 *
 *  Return n_symbols.
 */
int symbol_nsymbols(struct symbol_context *sc)
{
        return sc->n_symbols;
}


/*
 *  get_symbol_addr():
 *
 *  Find a symbol by name. If addr is non-NULL, *addr is set to the symbol's
 *  address. Return value is 1 if the symbol is found, 0 otherwise.
 *
 *  NOTE:  This is O(n).
 */
int get_symbol_addr(struct symbol_context *sc, char *symbol, uint64_t *addr)
{
        struct symbol *s;

        if (sc->sorted_array) {
                int i;
                for (i=0; i<sc->n_symbols; i++)
                        if (strcmp(symbol, sc->first_symbol[i].name) == 0) {
                                if (addr != NULL)
                                        *addr = sc->first_symbol[i].addr;
                                return 1;
                        }
        } else {
                s = sc->first_symbol;
                while (s != NULL) {
                        if (strcmp(symbol, s->name) == 0) {
                                if (addr != NULL)
                                        *addr = s->addr;
                                return 1;
                        }
                        s = s->next;
                }
        }

        return 0;
}


/*
 *  get_symbol_name_and_n_args():
 *
 *  Translate an address into a symbol name.  The return value is a pointer
 *  to a static char array, containing the symbol name.  (In other words,
 *  this function is not reentrant. This removes the need for memory allocation
 *  at the caller's side.)
 *
 *  If offset is not a NULL pointer, *offset is set to the offset within
 *  the symbol. For example, if there is a symbol at address 0x1000 with
 *  length 0x100, and a caller wants to know the symbol name of address
 *  0x1008, the symbol's name will be found in the static char array, and
 *  *offset will be set to 0x8.
 *
 *  If n_argsp is non-NULL, *n_argsp is set to the symbol's n_args value.
 *
 *  If no symbol was found, NULL is returned instead.
 */
static char symbol_buf[SYMBOLBUF_MAX+1];
char *get_symbol_name_and_n_args(struct symbol_context *sc, uint64_t addr,
        uint64_t *offset, int *n_argsp)
{
        struct symbol *s;

        if (sc->n_symbols == 0)
                return NULL;

        if ((addr >> 32) == 0 && (addr & 0x80000000ULL))
                addr |= 0xffffffff00000000ULL;

        symbol_buf[0] = symbol_buf[SYMBOLBUF_MAX] = '\0';
        if (offset != NULL)
                *offset = 0;

        if (!sc->sorted_array) {
                /*  Slow, linear O(n) search:  */
                s = sc->first_symbol;
                while (s != NULL) {
                        /*  Found a match?  */
                        if (addr >= s->addr && addr < s->addr + s->len) {
                                if (addr == s->addr)
                                        snprintf(symbol_buf, SYMBOLBUF_MAX,
                                            "%s", s->name);
                                else
                                        snprintf(symbol_buf, SYMBOLBUF_MAX,
                                            "%s+0x%"PRIx64, s->name, (uint64_t)
                                            (addr - s->addr));
                                if (offset != NULL)
                                        *offset = addr - s->addr;
                                if (n_argsp != NULL)
                                        *n_argsp = s->n_args;
                                return symbol_buf;
                        }
                        s = s->next;
                }
        } else {
                /*  Faster, O(log n) search:  */
                int lowest = 0, highest = sc->n_symbols - 1;
                while (lowest <= highest) {
                        int ofs = (lowest + highest) / 2;
                        s = sc->first_symbol + ofs;

                        /*  Found a match?  */
                        if (addr >= s->addr && addr < s->addr + s->len) {
                                if (addr == s->addr)
                                        snprintf(symbol_buf, SYMBOLBUF_MAX,
                                            "%s", s->name);
                                else
                                        snprintf(symbol_buf, SYMBOLBUF_MAX,
                                            "%s+0x%"PRIx64, s->name, (uint64_t)
                                            (addr - s->addr));

                                if (offset != NULL)
                                        *offset = addr - s->addr;
                                if (n_argsp != NULL)
                                        *n_argsp = s->n_args;

                                return symbol_buf;
                        }

                        if (addr < s->addr)
                                highest = ofs - 1;
                        else
                                lowest = ofs + 1;
                }
        }

        /*  Not found? Then return NULL.  */
        return NULL;
}


/*
 *  get_symbol_name():
 *
 *  See get_symbol_name_and_n_args().
 */
char *get_symbol_name(struct symbol_context *sc, uint64_t addr, uint64_t *offs)
{
        return get_symbol_name_and_n_args(sc, addr, offs, NULL);
}


/*
 *  add_symbol_name():
 *
 *  Add a symbol to the symbol list.
 */
void add_symbol_name(struct symbol_context *sc,
        uint64_t addr, uint64_t len, char *name, int type, int n_args)
{
        struct symbol *s;

        if (sc->sorted_array) {
                fprintf(stderr, "add_symbol_name(): Internal error: the "
                    "symbol array is already sorted\n");
                exit(1);
        }

        if (name == NULL) {
                fprintf(stderr, "add_symbol_name(): name = NULL\n");
                exit(1);
        }

        if (addr == 0 && strcmp(name, "_DYNAMIC_LINK") == 0)
                return;

        if (name[0] == '\0')
                return;

        /*  TODO: Maybe this should be optional?  */
        if (name[0] == '.' || name[0] == '$')
                return;

        /*  Quick test-hack:  */
        if (n_args < 0) {
                if (strcmp(name, "strlen") == 0)
                        n_args = 1;
                if (strcmp(name, "strcmp") == 0)
                        n_args = 2;
                if (strcmp(name, "strcpy") == 0)
                        n_args = 2;
                if (strcmp(name, "strncpy") == 0)
                        n_args = 3;
                if (strcmp(name, "strlcpy") == 0)
                        n_args = 3;
                if (strcmp(name, "strlcat") == 0)
                        n_args = 3;
                if (strcmp(name, "strncmp") == 0)
                        n_args = 3;
                if (strcmp(name, "memset") == 0)
                        n_args = 3;
                if (strcmp(name, "memcpy") == 0)
                        n_args = 3;
                if (strcmp(name, "bzero") == 0)
                        n_args = 2;
                if (strcmp(name, "bcopy") == 0)
                        n_args = 3;
        }

        if ((addr >> 32) == 0 && (addr & 0x80000000ULL))
                addr |= 0xffffffff00000000ULL;

        s = malloc(sizeof(struct symbol));
        if (s == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(s, 0, sizeof(struct symbol));

        s->name = symbol_demangle_cplusplus(name);

        if (s->name == NULL) {
                s->name = strdup(name);
                if (s->name == NULL) {
                        fprintf(stderr, "out of memory\n");
                        exit(1);
                }
        }

        s->addr   = addr;
        s->len    = len;
        s->type   = type;
        s->n_args = n_args;

        sc->n_symbols ++;

        /*  Add first in list:  */
        s->next = sc->first_symbol;
        sc->first_symbol = s;
}


/*
 *  symbol_readfile():
 *
 *  Read 'nm -S' style symbols from a file.
 *
 *  TODO: This function is an ugly hack, and should be replaced
 *  with something that reads symbols directly from the executable
 *  images.
 */
void symbol_readfile(struct symbol_context *sc, char *fname)
{
        FILE *f;
        char b1[80]; uint64_t addr;
        char b2[80]; uint64_t len;
        char b3[80]; int type;
        char b4[80];
        int cur_n_symbols = sc->n_symbols;

        f = fopen(fname, "r");
        if (f == NULL) {
                perror(fname);
                exit(1);
        }

        while (!feof(f)) {
                memset(b1, 0, sizeof(b1));
                memset(b2, 0, sizeof(b2));
                memset(b3, 0, sizeof(b3));
                memset(b4, 0, sizeof(b4));
                fscanf(f, "%s %s\n", b1,b2);
                if (strlen(b2) < 2 && !(b2[0]>='0' && b2[0]<='9')) {
                        strlcpy(b3, b2, sizeof(b3));
                        strlcpy(b2, "0", sizeof(b2));
                        fscanf(f, "%s\n", b4);
                } else {
                        fscanf(f, "%s %s\n", b3,b4);
                }

                /*  printf("b1='%s' b2='%s' b3='%s' b4='%s'\n",
                    b1,b2,b3,b4);  */
                addr = strtoull(b1, NULL, 16);
                len  = strtoull(b2, NULL, 16);
                type = b3[0];
                /*  printf("addr=%016llx len=%016llx type=%i\n",
                    addr, len, type);  */

                if (type == 't' || type == 'r' || type == 'g')
                        continue;

                add_symbol_name(sc, addr, len, b4, type, -1);
        }

        fclose(f);

        debug("%i symbols\n", sc->n_symbols - cur_n_symbols);
}


/*
 *  sym_addr_compare():
 *
 *  Helper function for sorting symbols according to their address.
 */
int sym_addr_compare(const void *a, const void *b)
{
        struct symbol *p1 = (struct symbol *) a;
        struct symbol *p2 = (struct symbol *) b;

        if (p1->addr < p2->addr)
                return -1;
        if (p1->addr > p2->addr)
                return 1;

        return 0;
}


/*
 *  symbol_recalc_sizes():
 *
 *  Recalculate sizes of symbols that have size = 0, by creating an array
 *  containing all symbols, qsort()-ing that array according to address, and
 *  recalculating the size fields if necessary.
 */
void symbol_recalc_sizes(struct symbol_context *sc)
{
        struct symbol *tmp_array;
        struct symbol *last_ptr;
        struct symbol *tmp_ptr;
        int i;

        tmp_array = malloc(sizeof (struct symbol) * sc->n_symbols);
        if (tmp_array == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        /*  Copy first_symbol --> tmp_array, and remove the old
                first_symbol at the same time:  */
        tmp_ptr = sc->first_symbol;
        i = 0;
        while (tmp_ptr != NULL) {
                tmp_array[i] = *tmp_ptr;
                last_ptr = tmp_ptr;
                tmp_ptr = tmp_ptr->next;
                free(last_ptr);
                i++;
        }

        qsort(tmp_array, sc->n_symbols, sizeof(struct symbol),
            sym_addr_compare);
        sc->sorted_array = 1;

        /*  Recreate the first_symbol chain:  */
        sc->first_symbol = NULL;
        for (i=0; i<sc->n_symbols; i++) {
                /*  Recalculate size, if 0:  */
                if (tmp_array[i].len == 0) {
                        uint64_t len;
                        if (i != sc->n_symbols-1)
                                len = tmp_array[i+1].addr
                                    - tmp_array[i].addr;
                        else
                                len = 1;

                        tmp_array[i].len = len;
                }

                tmp_array[i].next = &tmp_array[i+1];
        }

        sc->first_symbol = tmp_array;
}


/*
 *  symbol_init():
 *
 *  Initialize the symbol hashtables.
 */
void symbol_init(struct symbol_context *sc)
{
        sc->first_symbol = NULL;
        sc->sorted_array = 0;
        sc->n_symbols = 0;
}

1	dpavlin	2	/*
2	dpavlin	34	* Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3	dpavlin	2	*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	40	* $Id: symbol.c,v 1.38 2007/04/22 14:32:01 debug Exp $
29	dpavlin	2	*
30			* Address to symbol translation routines.
31			*
32	dpavlin	18	* This module is (probably) independent from the rest of the emulator.
33			* symbol_init() must be called before any other function in this file is used.
34	dpavlin	2	*/
35
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <string.h>
39
40			#include "symbol.h"
41
42
43			#define SYMBOLBUF_MAX 100
44
45
46			/*
47			* symbol_nsymbols():
48			*
49			* Return n_symbols.
50			*/
51			int symbol_nsymbols(struct symbol_context *sc)
52			{
53			return sc->n_symbols;
54			}
55
56
57			/*
58			* get_symbol_addr():
59			*
60			* Find a symbol by name. If addr is non-NULL, *addr is set to the symbol's
61			* address. Return value is 1 if the symbol is found, 0 otherwise.
62			*
63			* NOTE: This is O(n).
64			*/
65			int get_symbol_addr(struct symbol_context sc, char symbol, uint64_t *addr)
66			{
67			struct symbol *s;
68
69			if (sc->sorted_array) {
70			int i;
71			for (i=0; i<sc->n_symbols; i++)
72			if (strcmp(symbol, sc->first_symbol[i].name) == 0) {
73			if (addr != NULL)
74			*addr = sc->first_symbol[i].addr;
75			return 1;
76			}
77			} else {
78			s = sc->first_symbol;
79			while (s != NULL) {
80			if (strcmp(symbol, s->name) == 0) {
81			if (addr != NULL)
82			*addr = s->addr;
83			return 1;
84			}
85			s = s->next;
86			}
87			}
88
89			return 0;
90			}
91
92
93			/*
94	dpavlin	12	* get_symbol_name_and_n_args():
95	dpavlin	2	*
96			* Translate an address into a symbol name. The return value is a pointer
97			* to a static char array, containing the symbol name. (In other words,
98			* this function is not reentrant. This removes the need for memory allocation
99			* at the caller's side.)
100			*
101			* If offset is not a NULL pointer, *offset is set to the offset within
102			* the symbol. For example, if there is a symbol at address 0x1000 with
103			* length 0x100, and a caller wants to know the symbol name of address
104			* 0x1008, the symbol's name will be found in the static char array, and
105			* *offset will be set to 0x8.
106			*
107	dpavlin	12	* If n_argsp is non-NULL, *n_argsp is set to the symbol's n_args value.
108			*
109	dpavlin	2	* If no symbol was found, NULL is returned instead.
110			*/
111			static char symbol_buf[SYMBOLBUF_MAX+1];
112	dpavlin	12	char get_symbol_name_and_n_args(struct symbol_context sc, uint64_t addr,
113			uint64_t offset, int n_argsp)
114	dpavlin	2	{
115			struct symbol *s;
116
117			if (sc->n_symbols == 0)
118			return NULL;
119
120			if ((addr >> 32) == 0 && (addr & 0x80000000ULL))
121			addr \|= 0xffffffff00000000ULL;
122
123			symbol_buf[0] = symbol_buf[SYMBOLBUF_MAX] = '\0';
124			if (offset != NULL)
125			*offset = 0;
126
127			if (!sc->sorted_array) {
128			/* Slow, linear O(n) search: */
129			s = sc->first_symbol;
130			while (s != NULL) {
131			/* Found a match? */
132			if (addr >= s->addr && addr < s->addr + s->len) {
133			if (addr == s->addr)
134			snprintf(symbol_buf, SYMBOLBUF_MAX,
135			"%s", s->name);
136			else
137			snprintf(symbol_buf, SYMBOLBUF_MAX,
138	dpavlin	40	"%s+0x%"PRIx64, s->name, (uint64_t)
139	dpavlin	2	(addr - s->addr));
140			if (offset != NULL)
141			*offset = addr - s->addr;
142	dpavlin	12	if (n_argsp != NULL)
143			*n_argsp = s->n_args;
144	dpavlin	2	return symbol_buf;
145			}
146			s = s->next;
147			}
148			} else {
149			/* Faster, O(log n) search: */
150	dpavlin	40	int lowest = 0, highest = sc->n_symbols - 1;
151			while (lowest <= highest) {
152			int ofs = (lowest + highest) / 2;
153	dpavlin	2	s = sc->first_symbol + ofs;
154
155			/* Found a match? */
156			if (addr >= s->addr && addr < s->addr + s->len) {
157			if (addr == s->addr)
158			snprintf(symbol_buf, SYMBOLBUF_MAX,
159			"%s", s->name);
160			else
161			snprintf(symbol_buf, SYMBOLBUF_MAX,
162	dpavlin	40	"%s+0x%"PRIx64, s->name, (uint64_t)
163	dpavlin	2	(addr - s->addr));
164	dpavlin	40
165	dpavlin	2	if (offset != NULL)
166			*offset = addr - s->addr;
167	dpavlin	12	if (n_argsp != NULL)
168			*n_argsp = s->n_args;
169	dpavlin	40
170	dpavlin	2	return symbol_buf;
171			}
172
173	dpavlin	40	if (addr < s->addr)
174			highest = ofs - 1;
175			else
176			lowest = ofs + 1;
177	dpavlin	2	}
178			}
179
180			/* Not found? Then return NULL. */
181			return NULL;
182			}
183
184
185			/*
186	dpavlin	12	* get_symbol_name():
187			*
188			* See get_symbol_name_and_n_args().
189			*/
190			char get_symbol_name(struct symbol_context sc, uint64_t addr, uint64_t *offs)
191			{
192			return get_symbol_name_and_n_args(sc, addr, offs, NULL);
193			}
194
195
196			/*
197	dpavlin	2	* add_symbol_name():
198			*
199			* Add a symbol to the symbol list.
200			*/
201			void add_symbol_name(struct symbol_context *sc,
202	dpavlin	12	uint64_t addr, uint64_t len, char *name, int type, int n_args)
203	dpavlin	2	{
204			struct symbol *s;
205
206			if (sc->sorted_array) {
207			fprintf(stderr, "add_symbol_name(): Internal error: the "
208			"symbol array is already sorted\n");
209			exit(1);
210			}
211
212	dpavlin	4	if (name == NULL) {
213			fprintf(stderr, "add_symbol_name(): name = NULL\n");
214			exit(1);
215			}
216
217	dpavlin	28	if (addr == 0 && strcmp(name, "_DYNAMIC_LINK") == 0)
218			return;
219
220	dpavlin	10	if (name[0] == '\0')
221			return;
222
223	dpavlin	4	/* TODO: Maybe this should be optional? */
224	dpavlin	12	if (name[0] == '.' \|\| name[0] == '$')
225	dpavlin	4	return;
226
227	dpavlin	12	/* Quick test-hack: */
228			if (n_args < 0) {
229			if (strcmp(name, "strlen") == 0)
230			n_args = 1;
231			if (strcmp(name, "strcmp") == 0)
232			n_args = 2;
233			if (strcmp(name, "strcpy") == 0)
234			n_args = 2;
235	dpavlin	14	if (strcmp(name, "strncpy") == 0)
236			n_args = 3;
237			if (strcmp(name, "strlcpy") == 0)
238			n_args = 3;
239			if (strcmp(name, "strlcat") == 0)
240			n_args = 3;
241	dpavlin	12	if (strcmp(name, "strncmp") == 0)
242			n_args = 3;
243			if (strcmp(name, "memset") == 0)
244			n_args = 3;
245			if (strcmp(name, "memcpy") == 0)
246			n_args = 3;
247			if (strcmp(name, "bzero") == 0)
248			n_args = 2;
249			if (strcmp(name, "bcopy") == 0)
250			n_args = 3;
251			}
252
253	dpavlin	2	if ((addr >> 32) == 0 && (addr & 0x80000000ULL))
254			addr \|= 0xffffffff00000000ULL;
255
256			s = malloc(sizeof(struct symbol));
257			if (s == NULL) {
258			fprintf(stderr, "out of memory\n");
259			exit(1);
260			}
261
262	dpavlin	24	memset(s, 0, sizeof(struct symbol));
263
264			s->name = symbol_demangle_cplusplus(name);
265
266	dpavlin	2	if (s->name == NULL) {
267	dpavlin	24	s->name = strdup(name);
268			if (s->name == NULL) {
269			fprintf(stderr, "out of memory\n");
270			exit(1);
271			}
272	dpavlin	2	}
273	dpavlin	24
274	dpavlin	12	s->addr = addr;
275			s->len = len;
276			s->type = type;
277			s->n_args = n_args;
278	dpavlin	2
279			sc->n_symbols ++;
280
281			/* Add first in list: */
282			s->next = sc->first_symbol;
283			sc->first_symbol = s;
284			}
285
286
287			/*
288			* symbol_readfile():
289			*
290			* Read 'nm -S' style symbols from a file.
291			*
292			* TODO: This function is an ugly hack, and should be replaced
293			* with something that reads symbols directly from the executable
294			* images.
295			*/
296			void symbol_readfile(struct symbol_context sc, char fname)
297			{
298			FILE *f;
299			char b1[80]; uint64_t addr;
300			char b2[80]; uint64_t len;
301			char b3[80]; int type;
302			char b4[80];
303			int cur_n_symbols = sc->n_symbols;
304
305			f = fopen(fname, "r");
306			if (f == NULL) {
307			perror(fname);
308			exit(1);
309			}
310
311			while (!feof(f)) {
312			memset(b1, 0, sizeof(b1));
313			memset(b2, 0, sizeof(b2));
314			memset(b3, 0, sizeof(b3));
315			memset(b4, 0, sizeof(b4));
316			fscanf(f, "%s %s\n", b1,b2);
317			if (strlen(b2) < 2 && !(b2[0]>='0' && b2[0]<='9')) {
318	dpavlin	10	strlcpy(b3, b2, sizeof(b3));
319			strlcpy(b2, "0", sizeof(b2));
320	dpavlin	2	fscanf(f, "%s\n", b4);
321			} else {
322			fscanf(f, "%s %s\n", b3,b4);
323			}
324
325			/* printf("b1='%s' b2='%s' b3='%s' b4='%s'\n",
326			b1,b2,b3,b4); */
327			addr = strtoull(b1, NULL, 16);
328			len = strtoull(b2, NULL, 16);
329			type = b3[0];
330			/* printf("addr=%016llx len=%016llx type=%i\n",
331			addr, len, type); */
332
333			if (type == 't' \|\| type == 'r' \|\| type == 'g')
334			continue;
335
336	dpavlin	12	add_symbol_name(sc, addr, len, b4, type, -1);
337	dpavlin	2	}
338
339			fclose(f);
340
341			debug("%i symbols\n", sc->n_symbols - cur_n_symbols);
342			}
343
344
345			/*
346			* sym_addr_compare():
347			*
348			* Helper function for sorting symbols according to their address.
349			*/
350			int sym_addr_compare(const void a, const void b)
351			{
352			struct symbol p1 = (struct symbol ) a;
353			struct symbol p2 = (struct symbol ) b;
354
355			if (p1->addr < p2->addr)
356			return -1;
357			if (p1->addr > p2->addr)
358			return 1;
359
360			return 0;
361			}
362
363
364			/*
365			* symbol_recalc_sizes():
366			*
367			* Recalculate sizes of symbols that have size = 0, by creating an array
368			* containing all symbols, qsort()-ing that array according to address, and
369			* recalculating the size fields if necessary.
370			*/
371			void symbol_recalc_sizes(struct symbol_context *sc)
372			{
373			struct symbol *tmp_array;
374			struct symbol *last_ptr;
375			struct symbol *tmp_ptr;
376			int i;
377
378			tmp_array = malloc(sizeof (struct symbol) * sc->n_symbols);
379			if (tmp_array == NULL) {
380			fprintf(stderr, "out of memory\n");
381			exit(1);
382			}
383
384			/* Copy first_symbol --> tmp_array, and remove the old
385			first_symbol at the same time: */
386			tmp_ptr = sc->first_symbol;
387			i = 0;
388			while (tmp_ptr != NULL) {
389			tmp_array[i] = *tmp_ptr;
390			last_ptr = tmp_ptr;
391			tmp_ptr = tmp_ptr->next;
392			free(last_ptr);
393			i++;
394			}
395
396			qsort(tmp_array, sc->n_symbols, sizeof(struct symbol),
397			sym_addr_compare);
398			sc->sorted_array = 1;
399
400			/* Recreate the first_symbol chain: */
401			sc->first_symbol = NULL;
402			for (i=0; i<sc->n_symbols; i++) {
403			/* Recalculate size, if 0: */
404			if (tmp_array[i].len == 0) {
405			uint64_t len;
406			if (i != sc->n_symbols-1)
407			len = tmp_array[i+1].addr
408			- tmp_array[i].addr;
409			else
410			len = 1;
411	dpavlin	40
412	dpavlin	2	tmp_array[i].len = len;
413			}
414
415			tmp_array[i].next = &tmp_array[i+1];
416			}
417
418			sc->first_symbol = tmp_array;
419			}
420
421
422			/*
423			* symbol_init():
424			*
425			* Initialize the symbol hashtables.
426			*/
427			void symbol_init(struct symbol_context *sc)
428			{
429			sc->first_symbol = NULL;
430			sc->sorted_array = 0;
431			sc->n_symbols = 0;
432			}
433