xref: /dragonfly/contrib/gdb-7/bfd/verilog.c (revision 6e278935)
1 /* BFD back-end for verilog hex memory dump files.
2    Copyright 2009, 2010
3    Free Software Foundation, Inc.
4    Written by Anthony Green <green@moxielogic.com>
5 
6    This file is part of BFD, the Binary File Descriptor library.
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, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22 
23 
24 /* SUBSECTION
25 	Verilog hex memory file handling
26 
27    DESCRIPTION
28 
29 	Verilog hex memory files cannot hold anything but addresses
30 	and data, so that's all that we implement.
31 
32 	The syntax of the text file is described in the IEEE standard
33 	for Verilog.  Briefly, the file contains two types of tokens:
34 	data and optional addresses.  The tokens are separated by
35 	whitespace and comments.  Comments may be single line or
36 	multiline, using syntax similar to C++.  Addresses are
37 	specified by a leading "at" character (@) and are always
38 	hexadecimal strings.  Data and addresses may contain
39 	underscore (_) characters.
40 
41 	If no address is specified, the data is assumed to start at
42 	address 0.  Similarly, if data exists before the first
43 	specified address, then that data is assumed to start at
44 	address 0.
45 
46 
47    EXAMPLE
48 	@1000
49         01 ae 3f 45 12
50 
51    DESCRIPTION
52 	@1000 specifies the starting address for the memory data.
53 	The following characters describe the 5 bytes at 0x1000.  */
54 
55 
56 #include "sysdep.h"
57 #include "bfd.h"
58 #include "libbfd.h"
59 #include "libiberty.h"
60 #include "safe-ctype.h"
61 
62 /* Macros for converting between hex and binary.  */
63 
64 static const char digs[] = "0123456789ABCDEF";
65 
66 #define NIBBLE(x)    hex_value(x)
67 #define HEX(buffer) ((NIBBLE ((buffer)[0])<<4) + NIBBLE ((buffer)[1]))
68 #define TOHEX(d, x) \
69 	d[1] = digs[(x) & 0xf]; \
70 	d[0] = digs[((x) >> 4) & 0xf];
71 
72 /* When writing a verilog memory dump file, we write them in the order
73    in which they appear in memory. This structure is used to hold them
74    in memory.  */
75 
76 struct verilog_data_list_struct
77 {
78   struct verilog_data_list_struct *next;
79   bfd_byte * data;
80   bfd_vma where;
81   bfd_size_type size;
82 };
83 
84 typedef struct verilog_data_list_struct verilog_data_list_type;
85 
86 /* The verilog tdata information.  */
87 
88 typedef struct verilog_data_struct
89 {
90   verilog_data_list_type *head;
91   verilog_data_list_type *tail;
92 }
93 tdata_type;
94 
95 static bfd_boolean
96 verilog_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long mach)
97 {
98   if (arch != bfd_arch_unknown)
99     return bfd_default_set_arch_mach (abfd, arch, mach);
100 
101   abfd->arch_info = & bfd_default_arch_struct;
102   return TRUE;
103 }
104 
105 /* We have to save up all the outpu for a splurge before output.  */
106 
107 static bfd_boolean
108 verilog_set_section_contents (bfd *abfd,
109 			      sec_ptr section,
110 			      const void * location,
111 			      file_ptr offset,
112 			      bfd_size_type bytes_to_do)
113 {
114   tdata_type *tdata = abfd->tdata.verilog_data;
115   verilog_data_list_type *entry;
116 
117   entry = (verilog_data_list_type *) bfd_alloc (abfd, sizeof (* entry));
118   if (entry == NULL)
119     return FALSE;
120 
121   if (bytes_to_do
122       && (section->flags & SEC_ALLOC)
123       && (section->flags & SEC_LOAD))
124     {
125       bfd_byte *data;
126 
127       data = (bfd_byte *) bfd_alloc (abfd, bytes_to_do);
128       if (data == NULL)
129 	return FALSE;
130       memcpy ((void *) data, location, (size_t) bytes_to_do);
131 
132       entry->data = data;
133       entry->where = section->lma + offset;
134       entry->size = bytes_to_do;
135 
136       /* Sort the records by address.  Optimize for the common case of
137 	 adding a record to the end of the list.  */
138       if (tdata->tail != NULL
139 	  && entry->where >= tdata->tail->where)
140 	{
141 	  tdata->tail->next = entry;
142 	  entry->next = NULL;
143 	  tdata->tail = entry;
144 	}
145       else
146 	{
147 	  verilog_data_list_type **look;
148 
149 	  for (look = &tdata->head;
150 	       *look != NULL && (*look)->where < entry->where;
151 	       look = &(*look)->next)
152 	    ;
153 	  entry->next = *look;
154 	  *look = entry;
155 	  if (entry->next == NULL)
156 	    tdata->tail = entry;
157 	}
158     }
159   return TRUE;
160 }
161 
162 static bfd_boolean
163 verilog_write_address (bfd *abfd, bfd_vma address)
164 {
165   char buffer[12];
166   char *dst = buffer;
167   bfd_size_type wrlen;
168 
169   /* Write the address.  */
170   *dst++ = '@';
171   TOHEX (dst, (address >> 24));
172   dst += 2;
173   TOHEX (dst, (address >> 16));
174   dst += 2;
175   TOHEX (dst, (address >> 8));
176   dst += 2;
177   TOHEX (dst, (address));
178   dst += 2;
179   *dst++ = '\r';
180   *dst++ = '\n';
181   wrlen = dst - buffer;
182 
183   return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
184 }
185 
186 /* Write a record of type, of the supplied number of bytes. The
187    supplied bytes and length don't have a checksum. That's worked out
188    here.  */
189 
190 static bfd_boolean
191 verilog_write_record (bfd *abfd,
192 		      const bfd_byte *data,
193 		      const bfd_byte *end)
194 {
195   char buffer[48];
196   const bfd_byte *src = data;
197   char *dst = buffer;
198   bfd_size_type wrlen;
199 
200   /* Write the data.  */
201   for (src = data; src < end; src++)
202     {
203       TOHEX (dst, *src);
204       dst += 2;
205       *dst++ = ' ';
206     }
207   *dst++ = '\r';
208   *dst++ = '\n';
209   wrlen = dst - buffer;
210 
211   return bfd_bwrite ((void *) buffer, wrlen, abfd) == wrlen;
212 }
213 
214 static bfd_boolean
215 verilog_write_section (bfd *abfd,
216 		       tdata_type *tdata ATTRIBUTE_UNUSED,
217 		       verilog_data_list_type *list)
218 {
219   unsigned int octets_written = 0;
220   bfd_byte *location = list->data;
221 
222   verilog_write_address (abfd, list->where);
223   while (octets_written < list->size)
224     {
225       unsigned int octets_this_chunk = list->size - octets_written;
226 
227       if (octets_this_chunk > 16)
228 	octets_this_chunk = 16;
229 
230       if (! verilog_write_record (abfd,
231 				  location,
232 				  location + octets_this_chunk))
233 	return FALSE;
234 
235       octets_written += octets_this_chunk;
236       location += octets_this_chunk;
237     }
238 
239   return TRUE;
240 }
241 
242 static bfd_boolean
243 verilog_write_object_contents (bfd *abfd)
244 {
245   tdata_type *tdata = abfd->tdata.verilog_data;
246   verilog_data_list_type *list;
247 
248   /* Now wander though all the sections provided and output them.  */
249   list = tdata->head;
250 
251   while (list != (verilog_data_list_type *) NULL)
252     {
253       if (! verilog_write_section (abfd, tdata, list))
254 	return FALSE;
255       list = list->next;
256     }
257   return TRUE;
258 }
259 
260 /* Initialize by filling in the hex conversion array.  */
261 
262 static void
263 verilog_init (void)
264 {
265   static bfd_boolean inited = FALSE;
266 
267   if (! inited)
268     {
269       inited = TRUE;
270       hex_init ();
271     }
272 }
273 
274 /* Set up the verilog tdata information.  */
275 
276 static bfd_boolean
277 verilog_mkobject (bfd *abfd)
278 {
279   tdata_type *tdata;
280 
281   verilog_init ();
282 
283   tdata = (tdata_type *) bfd_alloc (abfd, sizeof (tdata_type));
284   if (tdata == NULL)
285     return FALSE;
286 
287   abfd->tdata.verilog_data = tdata;
288   tdata->head = NULL;
289   tdata->tail = NULL;
290 
291   return TRUE;
292 }
293 
294 #define	verilog_close_and_cleanup                    _bfd_generic_close_and_cleanup
295 #define verilog_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
296 #define verilog_new_section_hook                     _bfd_generic_new_section_hook
297 #define verilog_bfd_is_target_special_symbol         ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
298 #define verilog_bfd_is_local_label_name              bfd_generic_is_local_label_name
299 #define verilog_get_lineno                           _bfd_nosymbols_get_lineno
300 #define verilog_find_nearest_line                    _bfd_nosymbols_find_nearest_line
301 #define verilog_find_inliner_info                    _bfd_nosymbols_find_inliner_info
302 #define verilog_make_empty_symbol                    _bfd_generic_make_empty_symbol
303 #define verilog_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
304 #define verilog_read_minisymbols                     _bfd_generic_read_minisymbols
305 #define verilog_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
306 #define verilog_get_section_contents_in_window       _bfd_generic_get_section_contents_in_window
307 #define verilog_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
308 #define verilog_bfd_relax_section                    bfd_generic_relax_section
309 #define verilog_bfd_gc_sections                      bfd_generic_gc_sections
310 #define verilog_bfd_merge_sections                   bfd_generic_merge_sections
311 #define verilog_bfd_is_group_section                 bfd_generic_is_group_section
312 #define verilog_bfd_discard_group                    bfd_generic_discard_group
313 #define verilog_section_already_linked               _bfd_generic_section_already_linked
314 #define verilog_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
315 #define verilog_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
316 #define verilog_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
317 #define verilog_bfd_link_just_syms                   _bfd_generic_link_just_syms
318 #define verilog_bfd_final_link                       _bfd_generic_final_link
319 #define verilog_bfd_link_split_section               _bfd_generic_link_split_section
320 
321 const bfd_target verilog_vec =
322 {
323   "verilog",			/* Name.  */
324   bfd_target_verilog_flavour,
325   BFD_ENDIAN_UNKNOWN,		/* Target byte order.  */
326   BFD_ENDIAN_UNKNOWN,		/* Target headers byte order.  */
327   (HAS_RELOC | EXEC_P |		/* Object flags.  */
328    HAS_LINENO | HAS_DEBUG |
329    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
330   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
331    | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* Section flags.  */
332   0,				/* Leading underscore.  */
333   ' ',				/* AR_pad_char.  */
334   16,				/* AR_max_namelen.  */
335   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
336   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
337   bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* Data.  */
338   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
339   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
340   bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* Hdrs.  */
341 
342   {
343     _bfd_dummy_target,
344     _bfd_dummy_target,
345     _bfd_dummy_target,
346     _bfd_dummy_target,
347   },
348   {
349     bfd_false,
350     verilog_mkobject,
351     bfd_false,
352     bfd_false,
353   },
354   {				/* bfd_write_contents.  */
355     bfd_false,
356     verilog_write_object_contents,
357     bfd_false,
358     bfd_false,
359   },
360 
361   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
362   BFD_JUMP_TABLE_COPY (_bfd_generic),
363   BFD_JUMP_TABLE_CORE (_bfd_nocore),
364   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
365   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
366   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
367   BFD_JUMP_TABLE_WRITE (verilog),
368   BFD_JUMP_TABLE_LINK (_bfd_nolink),
369   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
370 
371   NULL,
372 
373   NULL
374 };
375