Automatic date update in version.in
[platform/upstream/binutils.git] / sim / rx / trace.c
1 /* trace.c --- tracing output for the RX simulator.
2
3 Copyright (C) 2005-2014 Free Software Foundation, Inc.
4 Contributed by Red Hat, Inc.
5
6 This file is part of the GNU simulators.
7
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.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21
22 #include "config.h"
23 #include <stdio.h>
24 #include <stdarg.h>
25 #include <string.h>
26 #include <stdlib.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <ctype.h>
30
31 #include "bfd.h"
32 #include "dis-asm.h"
33
34 #include "cpu.h"
35 #include "mem.h"
36 #include "load.h"
37
38 static int
39 sim_dis_read (bfd_vma memaddr, bfd_byte * ptr, unsigned int length,
40               struct disassemble_info *info)
41 {
42   int i;
43
44   if (rx_big_endian)
45     {
46       /* See load.c for an explanation of this.  */
47       for (i=0; i<length; i++)
48         ptr[i] = mem_get_qi ((memaddr + i) ^ 3);
49     }
50   else
51     mem_get_blk (memaddr, ptr, length);
52   return 0;
53 }
54
55 /* Filter out (in place) symbols that are useless for disassembly.
56    COUNT is the number of elements in SYMBOLS.
57    Return the number of useful symbols. */
58
59 static long
60 remove_useless_symbols (asymbol ** symbols, long count)
61 {
62   register asymbol **in_ptr = symbols, **out_ptr = symbols;
63
64   while (--count >= 0)
65     {
66       asymbol *sym = *in_ptr++;
67
68       if (strstr (sym->name, "gcc2_compiled"))
69         continue;
70       if (sym->name == NULL || sym->name[0] == '\0')
71         continue;
72       if (sym->flags & (BSF_DEBUGGING))
73         continue;
74       if (bfd_is_und_section (sym->section)
75           || bfd_is_com_section (sym->section))
76         continue;
77
78       *out_ptr++ = sym;
79     }
80   return out_ptr - symbols;
81 }
82
83 static int
84 compare_symbols (const PTR ap, const PTR bp)
85 {
86   const asymbol *a = *(const asymbol **) ap;
87   const asymbol *b = *(const asymbol **) bp;
88
89   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
90     return 1;
91   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
92     return -1;
93   return 0;
94 }
95
96 static char opbuf[1000];
97
98 static int
99 op_printf (char *buf, char *fmt, ...)
100 {
101   int ret;
102   va_list ap;
103
104   va_start (ap, fmt);
105   ret = vsprintf (opbuf + strlen (opbuf), fmt, ap);
106   va_end (ap);
107   return ret;
108 }
109
110 static bfd *       current_bfd = NULL;
111 static asymbol **  symtab = NULL;
112 static int         symcount = 0;
113 static asection *  code_section = NULL;
114 static bfd_vma     code_base = 0;
115 static struct disassemble_info info;
116
117 void
118 sim_disasm_init (bfd *prog)
119 {
120   current_bfd = prog;
121 }
122
123 typedef struct Files
124 {
125   struct Files *next;
126   char *filename;
127   int nlines;
128   char **lines;
129   char *data;
130 } Files;
131 Files *files = 0;
132
133 static char *
134 load_file_and_line (const char *filename, int lineno)
135 {
136   Files *f;
137   for (f = files; f; f = f->next)
138     if (strcmp (f->filename, filename) == 0)
139       break;
140   if (!f)
141     {
142       int i;
143       struct stat s;
144       const char *found_filename, *slash;
145
146       found_filename = filename;
147       while (1)
148         {
149           if (stat (found_filename, &s) == 0)
150             break;
151           slash = strchr (found_filename, '/');
152           if (!slash)
153             return "";
154           found_filename = slash + 1;
155         }
156
157       f = (Files *) malloc (sizeof (Files));
158       f->next = files;
159       files = f;
160       f->filename = strdup (filename);
161       f->data = (char *) malloc (s.st_size + 2);
162       FILE *file = fopen (found_filename, "rb");
163       fread (f->data, 1, s.st_size, file);
164       f->data[s.st_size] = 0;
165       fclose (file);
166
167       f->nlines = 1;
168       for (i = 0; i < s.st_size; i++)
169         if (f->data[i] == '\n')
170           f->nlines++;
171       f->lines = (char **) malloc (f->nlines * sizeof (char *));
172       f->lines[0] = f->data;
173       f->nlines = 1;
174       for (i = 0; i < s.st_size; i++)
175         if (f->data[i] == '\n')
176           {
177             f->lines[f->nlines] = f->data + i + 1;
178             while (*f->lines[f->nlines] == ' '
179                    || *f->lines[f->nlines] == '\t')
180               f->lines[f->nlines]++;
181             f->nlines++;
182             f->data[i] = 0;
183           }
184     }
185   if (lineno < 1 || lineno > f->nlines)
186     return "";
187   return f->lines[lineno - 1];
188 }
189
190 int
191 sim_get_current_source_location (const char **  pfilename,
192                                  const char **  pfunctionname,
193                                  unsigned int * plineno)
194 {
195   static int   initted = 0;
196   int          mypc = get_reg (pc);
197
198   if (current_bfd == NULL)
199     return 0;
200
201   if (!initted)
202     {
203       int storage;
204       asection * s;
205
206       initted = 1;
207       memset (& info, 0, sizeof (info));
208       INIT_DISASSEMBLE_INFO (info, stdout, op_printf);
209       info.read_memory_func = sim_dis_read;
210       info.arch = bfd_get_arch (current_bfd);
211       info.mach = bfd_get_mach (current_bfd);
212       if (info.mach == 0)
213         info.arch = bfd_arch_rx;
214
215       disassemble_init_for_target (& info);
216
217       storage = bfd_get_symtab_upper_bound (current_bfd);
218       if (storage > 0)
219         {
220           symtab = (asymbol **) malloc (storage);
221           symcount = bfd_canonicalize_symtab (current_bfd, symtab);
222           symcount = remove_useless_symbols (symtab, symcount);
223           qsort (symtab, symcount, sizeof (asymbol *), compare_symbols);
224         }
225
226       for (s = current_bfd->sections; s; s = s->next)
227         {
228           if (s->flags & SEC_CODE || code_section == 0)
229             {
230               code_section = s;
231               code_base = bfd_section_lma (current_bfd, s);
232               break;
233             }
234         }
235     }
236
237   *pfilename = *pfunctionname = NULL;
238   *plineno = 0;
239
240   bfd_find_nearest_line
241     (current_bfd, code_section, symtab, mypc - code_base,
242      pfilename, pfunctionname, plineno);
243
244   return 1;
245 }
246
247 void
248 sim_disasm_one (void)
249 {
250   static int           last_sym = -1;
251   static const char *  prev_filename = "";
252   static int           prev_lineno = 0;
253   const char *  filename;
254   const char *  functionname;
255   unsigned int  lineno;
256   int           sym, bestaddr;
257   int           min, max, i;
258   int           save_trace = trace;
259   int           mypc = get_reg (pc);
260
261   if (! sim_get_current_source_location (& filename, & functionname, & lineno))
262     return;
263
264   trace = 0;
265
266   if (filename && functionname && lineno)
267     {
268       if (lineno != prev_lineno || strcmp (prev_filename, filename))
269         {
270           char *       the_line = load_file_and_line (filename, lineno);
271           const char * slash = strrchr (filename, '/');
272
273           if (!slash)
274             slash = filename;
275           else
276             slash++;
277           printf
278             ("========================================"
279              "=====================================\n");
280           printf ("\033[37;41m %s:%d: \033[33;40m %s\033[K\033[0m\n",
281                   slash, lineno, the_line);
282         }
283       prev_lineno = lineno;
284       prev_filename = filename;
285     }
286
287   min = -1;
288   max = symcount;
289   while (min < max - 1)
290     {
291       bfd_vma sa;
292
293       sym = (min + max) / 2;
294       sa = bfd_asymbol_value (symtab[sym]);
295       /*printf("checking %4d %08x %s\n",
296         sym, sa, bfd_asymbol_name (symtab[sym])); */
297       if (sa > mypc)
298         max = sym;
299       else if (sa < mypc)
300         min = sym;
301       else
302         {
303           min = sym;
304           break;
305         }
306     }
307
308   if (min != -1 && min != last_sym)
309     {
310       bestaddr = bfd_asymbol_value (symtab[min]);
311       printf ("\033[43;30m%s", bfd_asymbol_name (symtab[min]));
312       if (bestaddr != mypc)
313         printf ("+%d", mypc - bestaddr);
314       printf (":\t\t\t\033[0m\n");
315       last_sym = min;
316 #if 0
317       if (trace == 1)
318         if (strcmp (bfd_asymbol_name (symtab[min]), "abort") == 0
319             || strcmp (bfd_asymbol_name (symtab[min]), "exit") == 0)
320           trace = 0;
321 #endif
322     }
323
324   opbuf[0] = 0;
325 #ifdef CYCLE_ACCURATE
326   printf ("\033[33m %04u %06x: ", (int)(regs.cycle_count % 10000), mypc);
327 #else
328   printf ("\033[33m %06x: ", mypc);
329
330 #endif
331
332   max = print_insn_rx (mypc, & info);
333
334   for (i = 0; i < max; i++)
335     {
336       if (rx_big_endian)
337         printf ("%02x", mem_get_qi ((mypc + i) ^ 3));
338       else
339         printf ("%02x", mem_get_qi (mypc + i));
340     }
341
342   do
343     {
344       printf ("  ");
345       i ++;
346     }
347   while (i < 6);
348
349   printf ("%-16s  ", opbuf);
350
351   printf ("\033[0m\n");
352   trace = save_trace;
353 }