URL https://opencores.org/ocsvn/amber/amber/trunk

Subversion Repositories amber

[/] [amber/] [trunk/] [sw/] [tools/] [amber-func-jumps.c] - Blame information for rev 11

Go to most recent revision | Details | Compare with Previous | View Log


/*----------------------------------------------------------------
//                                                              //
//  amber-func-jumps.c                                          //
//                                                              //
//  This file is part of the Amber project                      //
//  http://www.opencores.org/project,amber                      //
//                                                              //
//  Description                                                 //
//  Creates a little database of all the function names and     //
//  addresses is a given disassembly file and then uses it      //
//  to list out the jumps in the Amber disassembly log file.    //
//                                                              //
//  Author(s):                                                  //
//      - Conor Santifort, csantifort.amber@gmail.com           //
//                                                              //
//////////////////////////////////////////////////////////////////
//                                                              //
// Copyright (C) 2010 Authors and OPENCORES.ORG                 //
//                                                              //
// This source file may be used and distributed without         //
// restriction provided that this copyright statement is not    //
// removed from the file and that any derivative work contains  //
// the original copyright notice and the associated disclaimer. //
//                                                              //
// This source file is free software; you can redistribute it   //
// and/or modify it under the terms of the GNU Lesser General   //
// Public License as published by the Free Software Foundation; //
// either version 2.1 of the License, or (at your option) any   //
// later version.                                               //
//                                                              //
// This source is distributed in the hope that it will be       //
// useful, but WITHOUT ANY WARRANTY; without even the implied   //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //
// PURPOSE.  See the GNU Lesser General Public License for more //
// details.                                                     //
//                                                              //
// You should have received a copy of the GNU Lesser General    //
// Public License along with this source; if not, download it   //
// from http://www.opencores.org/lgpl.shtml                     //
//                                                              //
----------------------------------------------------------------*/
 
#include <stdio.h>
#include <stdlib.h> 
#include <string.h> 
#define NAMES_SIZE 20000
 
struct func_name
{
    char name[48];
    unsigned int address;
};
 
int conv_hstring ( char *string, unsigned int * addr)
{
int pos = 0;
*addr = 0;
 
while (((string[pos] >= '0' && string[pos] <= '9') ||
       (string[pos] >= 'a' && string[pos] <= 'f')) && pos < 9) {
    if (string[pos] >= '0' && string[pos] <= '9')
        *addr =  (*addr << 4) + ( string[pos++] - '0' );
    else
        *addr =  (*addr << 4) + ( string[pos++] - 'a' ) + 10;
    }
 
return pos;
}
 
 
unsigned int conv_dstring ( char *string, unsigned int * addr)
{
unsigned int pos = 0;
*addr = 0;
 
while (((string[pos] >= '0' && string[pos] <= '9')) && pos < 9) {
    *addr =  (*addr * 10) + ( string[pos++] - '0' );
    }
 
return pos;
}
 
 
int main (int argc, char **argv)
{
FILE *jumps_file;
FILE *func_names_file;
int i, num_func_names, to_func_num, found, exhausted, exact, start, mid, end;
int bytes_read;
size_t nbytes = 100;
char *line_buffer;
unsigned int addr;
 
struct func_name func_names [NAMES_SIZE];
char a[12], n[48];
char s_clk_count[12], s_from_addr[12], s_to_addr[12], s_r0[12];
unsigned int from_addr, to_addr, clk_count;
unsigned int x;
 
unsigned int slen;
 
if (argc < 3)
    {
    printf("errer agrc = %d - need jums file name, func_names file name\n", argc);
    return 1;
    }
 
jumps_file = fopen (argv[1], "r");
func_names_file = fopen (argv[2], "r");
 
 
if (jumps_file==NULL)
    {
    printf("jumps file open failed\n");
    return 1;
    }
 
if (func_names_file==NULL)
    {
    printf("jumps file open failed\n");
    return 1;
    }
 
 
/* Read the function names file into a structure */
/* reads a line */
line_buffer  = (char *) malloc (nbytes + 1);
 
i=0;
while (((bytes_read = getline (&line_buffer, &nbytes, func_names_file)) > 0) && i < NAMES_SIZE )
    {
    sscanf(line_buffer, "%s %s", a, n);
    if ( !conv_hstring(a, &addr) )
        {
        fprintf(stderr,"ERROR: conv_hstring error in func_names file with i = %d\n", i);
        return 1;
        }
    strcpy(func_names[i].name, n);
    func_names[i++].address = addr;
    }
 
 
if ( i == NAMES_SIZE )
    {
    fprintf(stderr, "WARNING: ran out of space in the function array, can only hold %d entries\n", i);
    return 1;
    }
 
num_func_names = i;
 
 
 
 
/* Assign names to jumps */
while ( (bytes_read = getline (&line_buffer, &nbytes, jumps_file)) > 0)
    {
    sscanf(line_buffer, "%s %s %s %s", s_clk_count, s_from_addr, s_to_addr, s_r0);
 
    if ( !conv_hstring(s_from_addr, &from_addr) )
        {
        fprintf(stderr,"ERROR: conv_hstring error in jumps file, from_addr, with i = %d\n", i);
        return 1;
        }
 
    if ( !conv_hstring(s_to_addr, &to_addr) )
        {
        fprintf(stderr,"ERROR: conv_hstring error in jumps file, to_addr, with i = %d\n", i);
        return 1;
        }
 
    if ( !conv_dstring(s_clk_count, &clk_count) )
        {
        fprintf(stderr,"ERROR: conv_dstring error in jumps file, r0, with i = %d\n", i);
        return 1;
        }
 
    /* find matching function name using binary search */
    found       = 0;
    exhausted   = 0;
    exact       = 0;
    start       = 0;
    end         = num_func_names-1;
 
    while ( !found && !exhausted )
        {
        mid = (start + end) / 2;
 
        if ( to_addr >= func_names[mid].address &&
             to_addr <  func_names[mid+1].address )
            {
            found = 1;
            to_func_num = mid;
            if ( to_addr == func_names[mid].address ) exact = 1;
            }
        else
            {
            if ( start == end ) exhausted = 1;
            else if ( start+1 == end )
                start += 1;
            else if (to_addr > func_names[mid].address)
                start = mid;
            else
                end = mid;
            }
        }
 
    /*
       now assign a function to the from_address
       this just assigns a function within the range
    */
    if (found)
        {
        found =0;
 
        start = 0;
        end = num_func_names-1;
 
        while (!found)
            {
            mid = (start + end) / 2;
 
            if ( from_addr >= func_names[mid].address &&
                 from_addr <  func_names[mid+1].address )
                {
                found = 1;
                if ( strcmp ( func_names[mid].name, func_names[to_func_num].name ) )
                    {
 
                    if ( exact ) {
                        if ( func_names[to_func_num].address < 0x02000000 )
                            printf("%9d u %s ->", clk_count, func_names[mid].name);
                        else
                            printf("%9d   %s ->", clk_count, func_names[mid].name);
 
                        slen = 35 - strlen ( func_names[mid].name );
                        if ( slen > 0 ) {
                            for (x=0;x<slen;x++) printf(" ");
                            }
 
 
                        if ( func_names[to_func_num].address < 0x02000000 )
                            printf("( %s ) %s u\n",
                                s_r0,
                                func_names[to_func_num].name);
                        else
                            printf("( %s ) %s\n",
                                s_r0,
                                func_names[to_func_num].name);
 
                        }
                    else {
                        printf("%9d   %s <-",
                                clk_count,
                                func_names[to_func_num].name);
 
                        slen = 35 - strlen ( func_names[to_func_num].name );
                        if ( slen > 0 ) {
                            for (x=0;x<slen;x++) printf(" ");
                            }
 
 
                        printf("( %s )\n",
                                s_r0);
                        }
                    }
                }
            else
                {
                if ( start == end )
                    found = 1;
                else if ( start+1 == end )
                    start += 1;
                else if (from_addr > func_names[mid].address)
                    start = mid;
                else
                    end = mid;
                }
            }
 
        }
 
    }
 
fclose(func_names_file);
fclose(jumps_file);
 
 
}
 
 

Browse

Tools

Subversion Repositories amber

[/] [amber/] [trunk/] [sw/] [tools/] [amber-func-jumps.c] - Blame information for rev 11

Line No.	Rev	Author	Line
1	2	csantifort	`/*----------------------------------------------------------------`
2			`// //`
3			`// amber-func-jumps.c //`
4			`// //`
5			`// This file is part of the Amber project //`
6			`// http://www.opencores.org/project,amber //`
7			`// //`
8			`// Description //`
9			`// Creates a little database of all the function names and //`
10			`// addresses is a given disassembly file and then uses it //`
11			`// to list out the jumps in the Amber disassembly log file. //`
12			`// //`
13			`// Author(s): //`
14			`// - Conor Santifort, csantifort.amber@gmail.com //`
15			`// //`
16			`//////////////////////////////////////////////////////////////////`
17			`// //`
18			`// Copyright (C) 2010 Authors and OPENCORES.ORG //`
19			`// //`
20			`// This source file may be used and distributed without //`
21			`// restriction provided that this copyright statement is not //`
22			`// removed from the file and that any derivative work contains //`
23			`// the original copyright notice and the associated disclaimer. //`
24			`// //`
25			`// This source file is free software; you can redistribute it //`
26			`// and/or modify it under the terms of the GNU Lesser General //`
27			`// Public License as published by the Free Software Foundation; //`
28			`// either version 2.1 of the License, or (at your option) any //`
29			`// later version. //`
30			`// //`
31			`// This source is distributed in the hope that it will be //`
32			`// useful, but WITHOUT ANY WARRANTY; without even the implied //`
33			`// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //`
34			`// PURPOSE. See the GNU Lesser General Public License for more //`
35			`// details. //`
36			`// //`
37			`// You should have received a copy of the GNU Lesser General //`
38			`// Public License along with this source; if not, download it //`
39			`// from http://www.opencores.org/lgpl.shtml //`
40			`// //`
41			`----------------------------------------------------------------*/`
42
43			`#include <stdio.h>`
44			`#include <stdlib.h>`
45			`#include <string.h>`
46			`#define NAMES_SIZE 20000`
47
48			`struct func_name`
49			`{`
50			`char name[48];`
51			`unsigned int address;`
52			`};`
53
54			`int conv_hstring ( char string, unsigned int addr)`
55			`{`
56			`int pos = 0;`
57			`*addr = 0;`
58
59			`while (((string[pos] >= '0' && string[pos] <= '9') \|\|`
60			`(string[pos] >= 'a' && string[pos] <= 'f')) && pos < 9) {`
61			`if (string[pos] >= '0' && string[pos] <= '9')`
62			`addr = (addr << 4) + ( string[pos++] - '0' );`
63			`else`
64			`addr = (addr << 4) + ( string[pos++] - 'a' ) + 10;`
65			`}`
66
67			`return pos;`
68			`}`
69
70
71			`unsigned int conv_dstring ( char string, unsigned int addr)`
72			`{`
73			`unsigned int pos = 0;`
74			`*addr = 0;`
75
76			`while (((string[pos] >= '0' && string[pos] <= '9')) && pos < 9) {`
77			`addr = (addr * 10) + ( string[pos++] - '0' );`
78			`}`
79
80			`return pos;`
81			`}`
82
83
84			`int main (int argc, char **argv)`
85			`{`
86			`FILE *jumps_file;`
87			`FILE *func_names_file;`
88			`int i, num_func_names, to_func_num, found, exhausted, exact, start, mid, end;`
89			`int bytes_read;`
90			`size_t nbytes = 100;`
91			`char *line_buffer;`
92			`unsigned int addr;`
93
94			`struct func_name func_names [NAMES_SIZE];`
95			`char a[12], n[48];`
96			`char s_clk_count[12], s_from_addr[12], s_to_addr[12], s_r0[12];`
97			`unsigned int from_addr, to_addr, clk_count;`
98			`unsigned int x;`
99
100			`unsigned int slen;`
101
102			`if (argc < 3)`
103			`{`
104			`printf("errer agrc = %d - need jums file name, func_names file name\n", argc);`
105			`return 1;`
106			`}`
107
108			`jumps_file = fopen (argv[1], "r");`
109			`func_names_file = fopen (argv[2], "r");`
110
111
112			`if (jumps_file==NULL)`
113			`{`
114			`printf("jumps file open failed\n");`
115			`return 1;`
116			`}`
117
118			`if (func_names_file==NULL)`
119			`{`
120			`printf("jumps file open failed\n");`
121			`return 1;`
122			`}`
123
124
125			`/* Read the function names file into a structure */`
126			`/* reads a line */`
127			`line_buffer = (char *) malloc (nbytes + 1);`
128
129			`i=0;`
130			`while (((bytes_read = getline (&line_buffer, &nbytes, func_names_file)) > 0) && i < NAMES_SIZE )`
131			`{`
132			`sscanf(line_buffer, "%s %s", a, n);`
133			`if ( !conv_hstring(a, &addr) )`
134			`{`
135			`fprintf(stderr,"ERROR: conv_hstring error in func_names file with i = %d\n", i);`
136			`return 1;`
137			`}`
138			`strcpy(func_names[i].name, n);`
139			`func_names[i++].address = addr;`
140			`}`
141
142
143			`if ( i == NAMES_SIZE )`
144			`{`
145			`fprintf(stderr, "WARNING: ran out of space in the function array, can only hold %d entries\n", i);`
146			`return 1;`
147			`}`
148
149			`num_func_names = i;`
150
151
152
153
154			`/* Assign names to jumps */`
155			`while ( (bytes_read = getline (&line_buffer, &nbytes, jumps_file)) > 0)`
156			`{`
157			`sscanf(line_buffer, "%s %s %s %s", s_clk_count, s_from_addr, s_to_addr, s_r0);`
158
159			`if ( !conv_hstring(s_from_addr, &from_addr) )`
160			`{`
161			`fprintf(stderr,"ERROR: conv_hstring error in jumps file, from_addr, with i = %d\n", i);`
162			`return 1;`
163			`}`
164
165			`if ( !conv_hstring(s_to_addr, &to_addr) )`
166			`{`
167			`fprintf(stderr,"ERROR: conv_hstring error in jumps file, to_addr, with i = %d\n", i);`
168			`return 1;`
169			`}`
170
171			`if ( !conv_dstring(s_clk_count, &clk_count) )`
172			`{`
173			`fprintf(stderr,"ERROR: conv_dstring error in jumps file, r0, with i = %d\n", i);`
174			`return 1;`
175			`}`
176
177			`/* find matching function name using binary search */`
178			`found = 0;`
179			`exhausted = 0;`
180			`exact = 0;`
181			`start = 0;`
182			`end = num_func_names-1;`
183
184			`while ( !found && !exhausted )`
185			`{`
186			`mid = (start + end) / 2;`
187
188			`if ( to_addr >= func_names[mid].address &&`
189			`to_addr < func_names[mid+1].address )`
190			`{`
191			`found = 1;`
192			`to_func_num = mid;`
193			`if ( to_addr == func_names[mid].address ) exact = 1;`
194			`}`
195			`else`
196			`{`
197			`if ( start == end ) exhausted = 1;`
198			`else if ( start+1 == end )`
199			`start += 1;`
200			`else if (to_addr > func_names[mid].address)`
201			`start = mid;`
202			`else`
203			`end = mid;`
204			`}`
205			`}`
206
207			`/*`
208			`now assign a function to the from_address`
209			`this just assigns a function within the range`
210			`*/`
211			`if (found)`
212			`{`
213			`found =0;`
214
215			`start = 0;`
216			`end = num_func_names-1;`
217
218			`while (!found)`
219			`{`
220			`mid = (start + end) / 2;`
221
222			`if ( from_addr >= func_names[mid].address &&`
223			`from_addr < func_names[mid+1].address )`
224			`{`
225			`found = 1;`
226			`if ( strcmp ( func_names[mid].name, func_names[to_func_num].name ) )`
227			`{`
228
229			`if ( exact ) {`
230	11	csantifort	`if ( func_names[to_func_num].address < 0x02000000 )`
231	2	csantifort	`printf("%9d u %s ->", clk_count, func_names[mid].name);`
232			`else`
233			`printf("%9d %s ->", clk_count, func_names[mid].name);`
234
235			`slen = 35 - strlen ( func_names[mid].name );`
236			`if ( slen > 0 ) {`
237			`for (x=0;x<slen;x++) printf(" ");`
238			`}`
239
240
241	11	csantifort	`if ( func_names[to_func_num].address < 0x02000000 )`
242	2	csantifort	`printf("( %s ) %s u\n",`
243			`s_r0,`
244			`func_names[to_func_num].name);`
245			`else`
246			`printf("( %s ) %s\n",`
247			`s_r0,`
248			`func_names[to_func_num].name);`
249
250			`}`
251			`else {`
252			`printf("%9d %s <-",`
253			`clk_count,`
254			`func_names[to_func_num].name);`
255
256			`slen = 35 - strlen ( func_names[to_func_num].name );`
257			`if ( slen > 0 ) {`
258			`for (x=0;x<slen;x++) printf(" ");`
259			`}`
260
261
262			`printf("( %s )\n",`
263			`s_r0);`
264			`}`
265			`}`
266			`}`
267			`else`
268			`{`
269			`if ( start == end )`
270			`found = 1;`
271			`else if ( start+1 == end )`
272			`start += 1;`
273			`else if (from_addr > func_names[mid].address)`
274			`start = mid;`
275			`else`
276			`end = mid;`
277			`}`
278			`}`
279
280			`}`
281
282			`}`
283
284			`fclose(func_names_file);`
285			`fclose(jumps_file);`
286
287
288			`}`
289
290