projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Many files: change all bfd_target vectors to be const. Change
[deliverable/binutils-gdb.git] / bfd / oasys.c
1 /* BFD back-end for oasys objects.
2 Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
3 Written by Steve Chamberlain of Cygnus Support, <sac@cygnus.com>.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #define UNDERSCORE_HACK 1
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "oasys.h"
26 #include "liboasys.h"
27
28 /* XXX - FIXME. offsetof belongs in the system-specific files in
29 ../include/sys. */
30 /* Define offsetof for those systems which lack it */
31
32 #ifndef offsetof
33 #define offsetof(type, identifier) (size_t) &(((type *) 0)->identifier)
34 #endif
35
36 static boolean oasys_read_record PARAMS ((bfd *,
37 oasys_record_union_type *));
38 static boolean oasys_write_sections PARAMS ((bfd *));
39 static boolean oasys_write_record PARAMS ((bfd *,
40 oasys_record_enum_type,
41 oasys_record_union_type *,
42 size_t));
43 static boolean oasys_write_syms PARAMS ((bfd *));
44 static boolean oasys_write_header PARAMS ((bfd *));
45 static boolean oasys_write_end PARAMS ((bfd *));
46 static boolean oasys_write_data PARAMS ((bfd *));
47
48 /* Read in all the section data and relocation stuff too */
49 PROTO (static boolean, oasys_slurp_section_data, (bfd * CONST abfd));
50
51 static boolean
52 oasys_read_record (abfd, record)
53 bfd *abfd;
54 oasys_record_union_type *record;
55 {
56 if (bfd_read ((PTR) record, 1, sizeof (record->header), abfd)
57 != sizeof (record->header))
58 return false;
59
60 if ((size_t) record->header.length <= (size_t) sizeof (record->header))
61 return true;
62 if (bfd_read ((PTR) (((char *) record) + sizeof (record->header)),
63 1, record->header.length - sizeof (record->header),
64 abfd)
65 != record->header.length - sizeof (record->header))
66 return false;
67 return true;
68 }
69 static size_t
70 oasys_string_length (record)
71 oasys_record_union_type *record;
72 {
73 return record->header.length
74 - ((char *) record->symbol.name - (char *) record);
75 }
76
77 /*****************************************************************************/
78
79 /*
80
81 Slurp the symbol table by reading in all the records at the start file
82 till we get to the first section record.
83
84 We'll sort the symbolss into two lists, defined and undefined. The
85 undefined symbols will be placed into the table according to their
86 refno.
87
88 We do this by placing all undefined symbols at the front of the table
89 moving in, and the defined symbols at the end of the table moving back.
90
91 */
92
93 static boolean
94 oasys_slurp_symbol_table (abfd)
95 bfd *CONST abfd;
96 {
97 oasys_record_union_type record;
98 oasys_data_type *data = OASYS_DATA (abfd);
99 boolean loop = true;
100 asymbol *dest_defined;
101 asymbol *dest;
102 char *string_ptr;
103
104
105 if (data->symbols != (asymbol *) NULL)
106 {
107 return true;
108 }
109 /* Buy enough memory for all the symbols and all the names */
110 data->symbols =
111 (asymbol *) bfd_alloc (abfd, sizeof (asymbol) * abfd->symcount);
112 #ifdef UNDERSCORE_HACK
113 /* buy 1 more char for each symbol to keep the underscore in*/
114 data->strings = bfd_alloc (abfd, data->symbol_string_length +
115 abfd->symcount);
116 #else
117 data->strings = bfd_alloc (abfd, data->symbol_string_length);
118 #endif
119 if (!data->symbols || !data->strings)
120 {
121 bfd_set_error (bfd_error_no_memory);
122 return false;
123 }
124
125 dest_defined = data->symbols + abfd->symcount - 1;
126
127 string_ptr = data->strings;
128 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
129 return false;
130 while (loop)
131 {
132
133 if (! oasys_read_record (abfd, &record))
134 return false;
135 switch (record.header.type)
136 {
137 case oasys_record_is_header_enum:
138 break;
139 case oasys_record_is_local_enum:
140 case oasys_record_is_symbol_enum:
141 {
142 int flag = record.header.type == (int) oasys_record_is_local_enum ?
143 (BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);
144
145
146 size_t length = oasys_string_length (&record);
147 switch (record.symbol.relb & RELOCATION_TYPE_BITS)
148 {
149 case RELOCATION_TYPE_ABS:
150 dest = dest_defined--;
151 dest->section = &bfd_abs_section;
152 dest->flags = 0;
153
154 break;
155 case RELOCATION_TYPE_REL:
156 dest = dest_defined--;
157 dest->section =
158 OASYS_DATA (abfd)->sections[record.symbol.relb &
159 RELOCATION_SECT_BITS];
160 if (record.header.type == (int) oasys_record_is_local_enum)
161 {
162 dest->flags = BSF_LOCAL;
163 if (dest->section == (asection *) (~0))
164 {
165 /* It seems that sometimes internal symbols are tied up, but
166 still get output, even though there is no
167 section */
168 dest->section = 0;
169 }
170 }
171 else
172 {
173
174 dest->flags = flag;
175 }
176 break;
177 case RELOCATION_TYPE_UND:
178 dest = data->symbols + bfd_h_get_16 (abfd, record.symbol.refno);
179 dest->section = &bfd_und_section;
180 break;
181 case RELOCATION_TYPE_COM:
182 dest = dest_defined--;
183 dest->name = string_ptr;
184 dest->the_bfd = abfd;
185
186 dest->section = &bfd_com_section;
187
188 break;
189 default:
190 dest = dest_defined--;
191 BFD_ASSERT (0);
192 break;
193 }
194 dest->name = string_ptr;
195 dest->the_bfd = abfd;
196 dest->udata = (PTR) NULL;
197 dest->value = bfd_h_get_32 (abfd, record.symbol.value);
198
199 #ifdef UNDERSCORE_HACK
200 if (record.symbol.name[0] != '_')
201 {
202 string_ptr[0] = '_';
203 string_ptr++;
204 }
205 #endif
206 memcpy (string_ptr, record.symbol.name, length);
207
208
209 string_ptr[length] = 0;
210 string_ptr += length + 1;
211 }
212 break;
213 default:
214 loop = false;
215 }
216 }
217 return true;
218 }
219
220 static long
221 oasys_get_symtab_upper_bound (abfd)
222 bfd *CONST abfd;
223 {
224 if (! oasys_slurp_symbol_table (abfd))
225 return -1;
226
227 return (abfd->symcount + 1) * (sizeof (oasys_symbol_type *));
228 }
229
230 /*
231 */
232
233 extern const bfd_target oasys_vec;
234
235 long
236 oasys_get_symtab (abfd, location)
237 bfd *abfd;
238 asymbol **location;
239 {
240 asymbol *symbase;
241 unsigned int counter;
242 if (oasys_slurp_symbol_table (abfd) == false)
243 {
244 return -1;
245 }
246 symbase = OASYS_DATA (abfd)->symbols;
247 for (counter = 0; counter < abfd->symcount; counter++)
248 {
249 *(location++) = symbase++;
250 }
251 *location = 0;
252 return abfd->symcount;
253 }
254
255 /***********************************************************************
256 * archive stuff
257 */
258
259 static const bfd_target *
260 oasys_archive_p (abfd)
261 bfd *abfd;
262 {
263 oasys_archive_header_type header;
264 oasys_extarchive_header_type header_ext;
265 unsigned int i;
266 file_ptr filepos;
267
268 if (bfd_seek (abfd, (file_ptr) 0, false) != 0
269 || (bfd_read ((PTR) & header_ext, 1, sizeof (header_ext), abfd)
270 != sizeof (header_ext)))
271 {
272 if (bfd_get_error () != bfd_error_system_call)
273 bfd_set_error (bfd_error_wrong_format);
274 return NULL;
275 }
276
277 header.version = bfd_h_get_32 (abfd, header_ext.version);
278 header.mod_count = bfd_h_get_32 (abfd, header_ext.mod_count);
279 header.mod_tbl_offset = bfd_h_get_32 (abfd, header_ext.mod_tbl_offset);
280 header.sym_tbl_size = bfd_h_get_32 (abfd, header_ext.sym_tbl_size);
281 header.sym_count = bfd_h_get_32 (abfd, header_ext.sym_count);
282 header.sym_tbl_offset = bfd_h_get_32 (abfd, header_ext.sym_tbl_offset);
283 header.xref_count = bfd_h_get_32 (abfd, header_ext.xref_count);
284 header.xref_lst_offset = bfd_h_get_32 (abfd, header_ext.xref_lst_offset);
285
286 /*
287 There isn't a magic number in an Oasys archive, so the best we
288 can do to verify reasnableness is to make sure that the values in
289 the header are too weird
290 */
291
292 if (header.version > 10000 ||
293 header.mod_count > 10000 ||
294 header.sym_count > 100000 ||
295 header.xref_count > 100000)
296 return (const bfd_target *) NULL;
297
298 /*
299 That all worked, let's buy the space for the header and read in
300 the headers.
301 */
302 {
303 oasys_ar_data_type *ar =
304 (oasys_ar_data_type *) bfd_alloc (abfd, sizeof (oasys_ar_data_type));
305
306 oasys_module_info_type *module =
307 (oasys_module_info_type *)
308 bfd_alloc (abfd, sizeof (oasys_module_info_type) * header.mod_count);
309 oasys_module_table_type record;
310
311 if (!ar || !module)
312 {
313 bfd_set_error (bfd_error_no_memory);
314 return NULL;
315 }
316
317 abfd->tdata.oasys_ar_data = ar;
318 ar->module = module;
319 ar->module_count = header.mod_count;
320
321 filepos = header.mod_tbl_offset;
322 for (i = 0; i < header.mod_count; i++)
323 {
324 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
325 return NULL;
326
327 /* There are two ways of specifying the archive header */
328
329 if (0)
330 {
331 oasys_extmodule_table_type_a_type record_ext;
332 if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
333 != sizeof (record_ext))
334 return NULL;
335
336 record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
337 record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
338
339 record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
340 record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
341 record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
342
343 module[i].name = bfd_alloc (abfd, 33);
344 if (!module[i].name)
345 {
346 bfd_set_error (bfd_error_no_memory);
347 return NULL;
348 }
349
350 memcpy (module[i].name, record_ext.mod_name, 33);
351 filepos +=
352 sizeof (record_ext) +
353 record.dep_count * 4 +
354 record.depee_count * 4 +
355 record.sect_count * 8 + 187;
356 }
357 else
358 {
359 oasys_extmodule_table_type_b_type record_ext;
360 if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
361 != sizeof (record_ext))
362 return NULL;
363
364 record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
365 record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
366
367 record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
368 record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
369 record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
370 record.module_name_size = bfd_h_get_32 (abfd, record_ext.mod_name_length);
371
372 module[i].name = bfd_alloc (abfd, record.module_name_size + 1);
373 if (!module[i].name)
374 {
375 bfd_set_error (bfd_error_no_memory);
376 return NULL;
377 }
378 if (bfd_read ((PTR) module[i].name, 1, record.module_name_size,
379 abfd)
380 != record.module_name_size)
381 return NULL;
382 module[i].name[record.module_name_size] = 0;
383 filepos +=
384 sizeof (record_ext) +
385 record.dep_count * 4 +
386 record.module_name_size + 1;
387
388 }
389
390
391 module[i].size = record.mod_size;
392 module[i].pos = record.file_offset;
393 module[i].abfd = 0;
394 }
395
396 }
397 return abfd->xvec;
398 }
399
400 static boolean
401 oasys_mkobject (abfd)
402 bfd *abfd;
403 {
404
405 abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, sizeof (oasys_data_type));
406 return abfd->tdata.oasys_obj_data ? true : false;
407 }
408
409 #define MAX_SECS 16
410 static const bfd_target *
411 oasys_object_p (abfd)
412 bfd *abfd;
413 {
414 oasys_data_type *oasys;
415 oasys_data_type *save = OASYS_DATA (abfd);
416 boolean loop = true;
417 boolean had_usefull = false;
418
419 abfd->tdata.oasys_obj_data = 0;
420 oasys_mkobject (abfd);
421 oasys = OASYS_DATA (abfd);
422 memset ((PTR) oasys->sections, 0xff, sizeof (oasys->sections));
423
424 /* Point to the start of the file */
425 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
426 goto fail;
427 oasys->symbol_string_length = 0;
428 /* Inspect the records, but only keep the section info -
429 remember the size of the symbols
430 */
431 oasys->first_data_record = 0;
432 while (loop)
433 {
434 oasys_record_union_type record;
435 if (! oasys_read_record (abfd, &record))
436 goto fail;
437 if ((size_t) record.header.length < (size_t) sizeof (record.header))
438 goto fail;
439
440
441 switch ((oasys_record_enum_type) (record.header.type))
442 {
443 case oasys_record_is_header_enum:
444 had_usefull = true;
445 break;
446 case oasys_record_is_symbol_enum:
447 case oasys_record_is_local_enum:
448 /* Count symbols and remember their size for a future malloc */
449 abfd->symcount++;
450 oasys->symbol_string_length += 1 + oasys_string_length (&record);
451 had_usefull = true;
452 break;
453 case oasys_record_is_section_enum:
454 {
455 asection *s;
456 char *buffer;
457 unsigned int section_number;
458 if (record.section.header.length != sizeof (record.section))
459 {
460 goto fail;
461 }
462 buffer = bfd_alloc (abfd, 3);
463 if (!buffer)
464 {
465 bfd_set_error (bfd_error_no_memory);
466 goto fail;
467 }
468 section_number = record.section.relb & RELOCATION_SECT_BITS;
469 sprintf (buffer, "%u", section_number);
470 s = bfd_make_section (abfd, buffer);
471 oasys->sections[section_number] = s;
472 switch (record.section.relb & RELOCATION_TYPE_BITS)
473 {
474 case RELOCATION_TYPE_ABS:
475 case RELOCATION_TYPE_REL:
476 break;
477 case RELOCATION_TYPE_UND:
478 case RELOCATION_TYPE_COM:
479 BFD_FAIL ();
480 }
481
482 s->_raw_size = bfd_h_get_32 (abfd, record.section.value);
483 s->vma = bfd_h_get_32 (abfd, record.section.vma);
484 s->flags = 0;
485 had_usefull = true;
486 }
487 break;
488 case oasys_record_is_data_enum:
489 oasys->first_data_record = bfd_tell (abfd) - record.header.length;
490 case oasys_record_is_debug_enum:
491 case oasys_record_is_module_enum:
492 case oasys_record_is_named_section_enum:
493 case oasys_record_is_end_enum:
494 if (had_usefull == false)
495 goto fail;
496 loop = false;
497 break;
498 default:
499 goto fail;
500 }
501 }
502 oasys->symbols = (asymbol *) NULL;
503 /*
504 Oasys support several architectures, but I can't see a simple way
505 to discover which one is in a particular file - we'll guess
506 */
507 bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);
508 if (abfd->symcount != 0)
509 {
510 abfd->flags |= HAS_SYMS;
511 }
512
513 /*
514 We don't know if a section has data until we've read it..
515 */
516
517 oasys_slurp_section_data (abfd);
518
519
520 return abfd->xvec;
521
522 fail:
523 (void) bfd_release (abfd, oasys);
524 abfd->tdata.oasys_obj_data = save;
525 return (const bfd_target *) NULL;
526 }
527
528
529 static void
530 oasys_get_symbol_info (ignore_abfd, symbol, ret)
531 bfd *ignore_abfd;
532 asymbol *symbol;
533 symbol_info *ret;
534 {
535 bfd_symbol_info (symbol, ret);
536 if (!symbol->section)
537 ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';
538 }
539
540 static void
541 oasys_print_symbol (ignore_abfd, afile, symbol, how)
542 bfd *ignore_abfd;
543 PTR afile;
544 asymbol *symbol;
545 bfd_print_symbol_type how;
546 {
547 FILE *file = (FILE *) afile;
548
549 switch (how)
550 {
551 case bfd_print_symbol_name:
552 case bfd_print_symbol_more:
553 fprintf (file, "%s", symbol->name);
554 break;
555 case bfd_print_symbol_all:
556 {
557 CONST char *section_name = symbol->section == (asection *) NULL ?
558 (CONST char *) "*abs" : symbol->section->name;
559
560 bfd_print_symbol_vandf ((PTR) file, symbol);
561
562 fprintf (file, " %-5s %s",
563 section_name,
564 symbol->name);
565 }
566 break;
567 }
568 }
569 /*
570 The howto table is build using the top two bits of a reloc byte to
571 index into it. The bits are PCREL,WORD/LONG
572 */
573 static reloc_howto_type howto_table[] =
574 {
575
576 HOWTO (0, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false),
577 HOWTO (0, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false),
578 HOWTO (0, 0, 1, 16, true, 0, complain_overflow_signed, 0, "pcrel16", true, 0x0000ffff, 0x0000ffff, false),
579 HOWTO (0, 0, 2, 32, true, 0, complain_overflow_signed, 0, "pcrel32", true, 0xffffffff, 0xffffffff, false)
580 };
581
582 /* Read in all the section data and relocation stuff too */
583 static boolean
584 oasys_slurp_section_data (abfd)
585 bfd *CONST abfd;
586 {
587 oasys_record_union_type record;
588 oasys_data_type *data = OASYS_DATA (abfd);
589 boolean loop = true;
590
591 oasys_per_section_type *per;
592
593 asection *s;
594
595 /* See if the data has been slurped already .. */
596 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
597 {
598 per = oasys_per_section (s);
599 if (per->initialized == true)
600 return true;
601 }
602
603 if (data->first_data_record == 0)
604 return true;
605
606 if (bfd_seek (abfd, data->first_data_record, SEEK_SET) != 0)
607 return false;
608 while (loop)
609 {
610 if (! oasys_read_record (abfd, &record))
611 return false;
612 switch (record.header.type)
613 {
614 case oasys_record_is_header_enum:
615 break;
616 case oasys_record_is_data_enum:
617 {
618
619 bfd_byte *src = record.data.data;
620 bfd_byte *end_src = ((bfd_byte *) & record) + record.header.length;
621 bfd_byte *dst_ptr;
622 bfd_byte *dst_base_ptr;
623 unsigned int relbit;
624 unsigned int count;
625 asection *section =
626 data->sections[record.data.relb & RELOCATION_SECT_BITS];
627 bfd_vma dst_offset;
628
629 per = oasys_per_section (section);
630
631 if (per->initialized == false)
632 {
633 per->data = (bfd_byte *) bfd_zalloc (abfd, section->_raw_size);
634 if (!per->data)
635 {
636 bfd_set_error (bfd_error_no_memory);
637 return false;
638 }
639 per->reloc_tail_ptr = (oasys_reloc_type **) & (section->relocation);
640 per->had_vma = false;
641 per->initialized = true;
642 section->reloc_count = 0;
643 section->flags = SEC_ALLOC;
644 }
645
646 dst_offset = bfd_h_get_32 (abfd, record.data.addr);
647 if (per->had_vma == false)
648 {
649 /* Take the first vma we see as the base */
650 section->vma = dst_offset;
651 per->had_vma = true;
652 }
653
654 dst_offset -= section->vma;
655
656 dst_base_ptr = oasys_per_section (section)->data;
657 dst_ptr = oasys_per_section (section)->data +
658 dst_offset;
659
660 if (src < end_src)
661 {
662 section->flags |= SEC_LOAD | SEC_HAS_CONTENTS;
663 }
664 while (src < end_src)
665 {
666 unsigned char mod_byte = *src++;
667 size_t gap = end_src - src;
668
669 count = 8;
670 if (mod_byte == 0 && gap >= 8)
671 {
672 dst_ptr[0] = src[0];
673 dst_ptr[1] = src[1];
674 dst_ptr[2] = src[2];
675 dst_ptr[3] = src[3];
676 dst_ptr[4] = src[4];
677 dst_ptr[5] = src[5];
678 dst_ptr[6] = src[6];
679 dst_ptr[7] = src[7];
680 dst_ptr += 8;
681 src += 8;
682 }
683 else
684 {
685 for (relbit = 1; count-- != 0 && src < end_src; relbit <<= 1)
686 {
687 if (relbit & mod_byte)
688 {
689 unsigned char reloc = *src;
690 /* This item needs to be relocated */
691 switch (reloc & RELOCATION_TYPE_BITS)
692 {
693 case RELOCATION_TYPE_ABS:
694
695 break;
696
697 case RELOCATION_TYPE_REL:
698 {
699 /* Relocate the item relative to the section */
700 oasys_reloc_type *r =
701 (oasys_reloc_type *)
702 bfd_alloc (abfd,
703 sizeof (oasys_reloc_type));
704 if (!r)
705 {
706 bfd_set_error (bfd_error_no_memory);
707 return false;
708 }
709 *(per->reloc_tail_ptr) = r;
710 per->reloc_tail_ptr = &r->next;
711 r->next = (oasys_reloc_type *) NULL;
712 /* Reference to undefined symbol */
713 src++;
714 /* There is no symbol */
715 r->symbol = 0;
716 /* Work out the howto */
717 abort ();
718 #if 0
719 r->relent.section =
720 data->sections[reloc &
721 RELOCATION_SECT_BITS];
722
723 r->relent.addend = -
724 r->relent.section->vma;
725 #endif
726 r->relent.address = dst_ptr - dst_base_ptr;
727 r->relent.howto = &howto_table[reloc >> 6];
728 r->relent.sym_ptr_ptr = (asymbol **) NULL;
729 section->reloc_count++;
730
731 /* Fake up the data to look like it's got the -ve pc in it, this makes
732 it much easier to convert into other formats. This is done by
733 hitting the addend.
734 */
735 if (r->relent.howto->pc_relative == true)
736 {
737 r->relent.addend -= dst_ptr - dst_base_ptr;
738 }
739
740
741 }
742 break;
743
744
745 case RELOCATION_TYPE_UND:
746 {
747 oasys_reloc_type *r =
748 (oasys_reloc_type *)
749 bfd_alloc (abfd,
750 sizeof (oasys_reloc_type));
751 if (!r)
752 {
753 bfd_set_error (bfd_error_no_memory);
754 return false;
755 }
756 *(per->reloc_tail_ptr) = r;
757 per->reloc_tail_ptr = &r->next;
758 r->next = (oasys_reloc_type *) NULL;
759 /* Reference to undefined symbol */
760 src++;
761 /* Get symbol number */
762 r->symbol = (src[0] << 8) | src[1];
763 /* Work out the howto */
764 abort ();
765
766 #if 0
767 r->relent.section = (asection
768 *) NULL;
769 #endif
770 r->relent.addend = 0;
771 r->relent.address = dst_ptr - dst_base_ptr;
772 r->relent.howto = &howto_table[reloc >> 6];
773 r->relent.sym_ptr_ptr = (asymbol **) NULL;
774 section->reloc_count++;
775
776 src += 2;
777 /* Fake up the data to look like it's got the -ve pc in it, this makes
778 it much easier to convert into other formats. This is done by
779 hitting the addend.
780 */
781 if (r->relent.howto->pc_relative == true)
782 {
783 r->relent.addend -= dst_ptr - dst_base_ptr;
784 }
785
786
787
788 }
789 break;
790 case RELOCATION_TYPE_COM:
791 BFD_FAIL ();
792 }
793 }
794 *dst_ptr++ = *src++;
795 }
796 }
797 }
798 }
799 break;
800 case oasys_record_is_local_enum:
801 case oasys_record_is_symbol_enum:
802 case oasys_record_is_section_enum:
803 break;
804 default:
805 loop = false;
806 }
807 }
808
809 return true;
810
811 }
812
813 static boolean
814 oasys_new_section_hook (abfd, newsect)
815 bfd *abfd;
816 asection *newsect;
817 {
818 newsect->used_by_bfd = (PTR)
819 bfd_alloc (abfd, sizeof (oasys_per_section_type));
820 if (!newsect->used_by_bfd)
821 {
822 bfd_set_error (bfd_error_no_memory);
823 return false;
824 }
825 oasys_per_section (newsect)->data = (bfd_byte *) NULL;
826 oasys_per_section (newsect)->section = newsect;
827 oasys_per_section (newsect)->offset = 0;
828 oasys_per_section (newsect)->initialized = false;
829 newsect->alignment_power = 1;
830 /* Turn the section string into an index */
831
832 sscanf (newsect->name, "%u", &newsect->target_index);
833
834 return true;
835 }
836
837
838 static long
839 oasys_get_reloc_upper_bound (abfd, asect)
840 bfd *abfd;
841 sec_ptr asect;
842 {
843 if (! oasys_slurp_section_data (abfd))
844 return -1;
845 return (asect->reloc_count + 1) * sizeof (arelent *);
846 }
847
848 static boolean
849 oasys_get_section_contents (abfd, section, location, offset, count)
850 bfd *abfd;
851 sec_ptr section;
852 PTR location;
853 file_ptr offset;
854 bfd_size_type count;
855 {
856 oasys_per_section_type *p = (oasys_per_section_type *) section->used_by_bfd;
857 oasys_slurp_section_data (abfd);
858 if (p->initialized == false)
859 {
860 (void) memset (location, 0, (int) count);
861 }
862 else
863 {
864 (void) memcpy (location, (PTR) (p->data + offset), (int) count);
865 }
866 return true;
867 }
868
869
870 long
871 oasys_canonicalize_reloc (ignore_abfd, section, relptr, symbols)
872 bfd *ignore_abfd;
873 sec_ptr section;
874 arelent **relptr;
875 asymbol **symbols;
876 {
877 unsigned int reloc_count = 0;
878 oasys_reloc_type *src = (oasys_reloc_type *) (section->relocation);
879 while (src != (oasys_reloc_type *) NULL)
880 {
881 abort ();
882
883 #if 0
884 if (src->relent.section == (asection *) NULL)
885 {
886 src->relent.sym_ptr_ptr = symbols + src->symbol;
887 }
888 #endif
889
890 *relptr++ = &src->relent;
891 src = src->next;
892 reloc_count++;
893 }
894 *relptr = (arelent *) NULL;
895 return section->reloc_count = reloc_count;
896 }
897
898
899
900
901 /* Writing */
902
903
904 /* Calculate the checksum and write one record */
905 static boolean
906 oasys_write_record (abfd, type, record, size)
907 bfd *abfd;
908 oasys_record_enum_type type;
909 oasys_record_union_type *record;
910 size_t size;
911 {
912 int checksum;
913 size_t i;
914 unsigned char *ptr;
915
916 record->header.length = size;
917 record->header.type = (int) type;
918 record->header.check_sum = 0;
919 record->header.fill = 0;
920 ptr = (unsigned char *) &record->pad[0];
921 checksum = 0;
922 for (i = 0; i < size; i++)
923 {
924 checksum += *ptr++;
925 }
926 record->header.check_sum = 0xff & (-checksum);
927 if (bfd_write ((PTR) record, 1, size, abfd) != size)
928 return false;
929 return true;
930 }
931
932
933 /* Write out all the symbols */
934 static boolean
935 oasys_write_syms (abfd)
936 bfd *abfd;
937 {
938 unsigned int count;
939 asymbol **generic = bfd_get_outsymbols (abfd);
940 unsigned int index = 0;
941 for (count = 0; count < bfd_get_symcount (abfd); count++)
942 {
943
944 oasys_symbol_record_type symbol;
945 asymbol *CONST g = generic[count];
946
947 CONST char *src = g->name;
948 char *dst = symbol.name;
949 unsigned int l = 0;
950
951 if (bfd_is_com_section (g->section))
952 {
953 symbol.relb = RELOCATION_TYPE_COM;
954 bfd_h_put_16 (abfd, index, symbol.refno);
955 index++;
956 }
957 else if (g->section == &bfd_abs_section)
958 {
959 symbol.relb = RELOCATION_TYPE_ABS;
960 bfd_h_put_16 (abfd, 0, symbol.refno);
961
962 }
963 else if (g->section == &bfd_und_section)
964 {
965 symbol.relb = RELOCATION_TYPE_UND;
966 bfd_h_put_16 (abfd, index, symbol.refno);
967 /* Overload the value field with the output index number */
968 index++;
969 }
970 else if (g->flags & BSF_DEBUGGING)
971 {
972 /* throw it away */
973 continue;
974 }
975 else
976 {
977 if (g->section == (asection *) NULL)
978 {
979 /* Sometime, the oasys tools give out a symbol with illegal
980 bits in it, we'll output it in the same broken way */
981
982 symbol.relb = RELOCATION_TYPE_REL | 0;
983 }
984 else
985 {
986 symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
987 }
988 bfd_h_put_16 (abfd, 0, symbol.refno);
989 }
990 #ifdef UNDERSCORE_HACK
991 if (src[l] == '_')
992 dst[l++] = '.';
993 #endif
994 while (src[l])
995 {
996 dst[l] = src[l];
997 l++;
998 }
999
1000 bfd_h_put_32 (abfd, g->value, symbol.value);
1001
1002
1003 if (g->flags & BSF_LOCAL)
1004 {
1005 if (! oasys_write_record (abfd,
1006 oasys_record_is_local_enum,
1007 (oasys_record_union_type *) & symbol,
1008 offsetof (oasys_symbol_record_type,
1009 name[0]) + l))
1010 return false;
1011 }
1012 else
1013 {
1014 if (! oasys_write_record (abfd,
1015 oasys_record_is_symbol_enum,
1016 (oasys_record_union_type *) & symbol,
1017 offsetof (oasys_symbol_record_type,
1018 name[0]) + l))
1019 return false;
1020 }
1021 g->value = index - 1;
1022 }
1023
1024 return true;
1025 }
1026
1027
1028 /* Write a section header for each section */
1029 static boolean
1030 oasys_write_sections (abfd)
1031 bfd *abfd;
1032 {
1033 asection *s;
1034 static oasys_section_record_type out;
1035
1036 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1037 {
1038 if (!isdigit (s->name[0]))
1039 {
1040 bfd_set_error (bfd_error_nonrepresentable_section);
1041 return false;
1042 }
1043 out.relb = RELOCATION_TYPE_REL | s->target_index;
1044 bfd_h_put_32 (abfd, s->_cooked_size, out.value);
1045 bfd_h_put_32 (abfd, s->vma, out.vma);
1046
1047 if (! oasys_write_record (abfd,
1048 oasys_record_is_section_enum,
1049 (oasys_record_union_type *) & out,
1050 sizeof (out)))
1051 return false;
1052 }
1053 return true;
1054 }
1055
1056 static boolean
1057 oasys_write_header (abfd)
1058 bfd *abfd;
1059 {
1060 /* Create and write the header */
1061 oasys_header_record_type r;
1062 size_t length = strlen (abfd->filename);
1063 if (length > (size_t) sizeof (r.module_name))
1064 {
1065 length = sizeof (r.module_name);
1066 }
1067
1068 (void) memcpy (r.module_name,
1069 abfd->filename,
1070 length);
1071 (void) memset (r.module_name + length,
1072 ' ',
1073 sizeof (r.module_name) - length);
1074
1075 r.version_number = OASYS_VERSION_NUMBER;
1076 r.rev_number = OASYS_REV_NUMBER;
1077 if (! oasys_write_record (abfd,
1078 oasys_record_is_header_enum,
1079 (oasys_record_union_type *) & r,
1080 offsetof (oasys_header_record_type,
1081 description[0])))
1082 return false;
1083
1084 return true;
1085 }
1086
1087 static boolean
1088 oasys_write_end (abfd)
1089 bfd *abfd;
1090 {
1091 oasys_end_record_type end;
1092 unsigned char null = 0;
1093 end.relb = RELOCATION_TYPE_ABS;
1094 bfd_h_put_32 (abfd, abfd->start_address, end.entry);
1095 bfd_h_put_16 (abfd, 0, end.fill);
1096 end.zero = 0;
1097 if (! oasys_write_record (abfd,
1098 oasys_record_is_end_enum,
1099 (oasys_record_union_type *) & end,
1100 sizeof (end)))
1101 return false;
1102 if (bfd_write ((PTR) & null, 1, 1, abfd) != 1)
1103 return false;
1104 return true;
1105 }
1106
1107 static int
1108 comp (ap, bp)
1109 CONST PTR ap;
1110 CONST PTR bp;
1111 {
1112 arelent *a = *((arelent **) ap);
1113 arelent *b = *((arelent **) bp);
1114 return a->address - b->address;
1115 }
1116
1117 /*
1118 Writing data..
1119
1120 */
1121 static boolean
1122 oasys_write_data (abfd)
1123 bfd *abfd;
1124 {
1125 asection *s;
1126 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1127 {
1128 if (s->flags & SEC_LOAD)
1129 {
1130 bfd_byte *raw_data = oasys_per_section (s)->data;
1131 oasys_data_record_type processed_data;
1132 bfd_size_type current_byte_index = 0;
1133 unsigned int relocs_to_go = s->reloc_count;
1134 arelent **p = s->orelocation;
1135 if (s->reloc_count != 0)
1136 {
1137 /* Sort the reloc records so it's easy to insert the relocs into the
1138 data */
1139
1140 qsort (s->orelocation,
1141 s->reloc_count,
1142 sizeof (arelent **),
1143 comp);
1144 }
1145 current_byte_index = 0;
1146 processed_data.relb = s->target_index | RELOCATION_TYPE_REL;
1147
1148 while (current_byte_index < s->_cooked_size)
1149 {
1150 /* Scan forwards by eight bytes or however much is left and see if
1151 there are any relocations going on */
1152 bfd_byte *mod = &processed_data.data[0];
1153 bfd_byte *dst = &processed_data.data[1];
1154
1155 unsigned int i = 0;
1156 *mod = 0;
1157
1158
1159 bfd_h_put_32 (abfd, s->vma + current_byte_index,
1160 processed_data.addr);
1161
1162 /* Don't start a relocation unless you're sure you can finish it
1163 within the same data record. The worst case relocation is a
1164 4-byte relocatable value which is split across two modification
1165 bytes (1 relocation byte + 2 symbol reference bytes + 2 data +
1166 1 modification byte + 2 data = 8 bytes total). That's where
1167 the magic number 8 comes from.
1168 */
1169 while (current_byte_index < s->_raw_size && dst <=
1170 &processed_data.data[sizeof (processed_data.data) - 8])
1171 {
1172
1173
1174 if (relocs_to_go != 0)
1175 {
1176 arelent *r = *p;
1177 const reloc_howto_type *const how = r->howto;
1178 /* There is a relocation, is it for this byte ? */
1179 if (r->address == current_byte_index)
1180 {
1181 unsigned char rel_byte;
1182
1183 p++;
1184 relocs_to_go--;
1185
1186 *mod |= (1 << i);
1187 if (how->pc_relative)
1188 {
1189 rel_byte = RELOCATION_PCREL_BIT;
1190
1191 /* Also patch the raw data so that it doesn't have
1192 the -ve stuff any more */
1193 if (how->size != 2)
1194 {
1195 bfd_put_16 (abfd,
1196 bfd_get_16 (abfd, raw_data) +
1197 current_byte_index, raw_data);
1198 }
1199
1200 else
1201 {
1202 bfd_put_32 (abfd,
1203 bfd_get_32 (abfd, raw_data) +
1204 current_byte_index, raw_data);
1205 }
1206 }
1207 else
1208 {
1209 rel_byte = 0;
1210 }
1211 if (how->size == 2)
1212 {
1213 rel_byte |= RELOCATION_32BIT_BIT;
1214 }
1215
1216 /* Is this a section relative relocation, or a symbol
1217 relative relocation ? */
1218 abort ();
1219
1220 #if 0
1221 if (r->section != (asection *) NULL)
1222 {
1223 /* The relent has a section attached, so it must be section
1224 relative */
1225 rel_byte |= RELOCATION_TYPE_REL;
1226 rel_byte |= r->section->output_section->target_index;
1227 *dst++ = rel_byte;
1228 }
1229 else
1230 #endif
1231 {
1232 asymbol *p = *(r->sym_ptr_ptr);
1233
1234 /* If this symbol has a section attached, then it
1235 has already been resolved. Change from a symbol
1236 ref to a section ref */
1237 if (p->section != (asection *) NULL)
1238 {
1239 rel_byte |= RELOCATION_TYPE_REL;
1240 rel_byte |=
1241 p->section->output_section->target_index;
1242 *dst++ = rel_byte;
1243 }
1244 else
1245 {
1246 rel_byte |= RELOCATION_TYPE_UND;
1247 *dst++ = rel_byte;
1248 /* Next two bytes are a symbol index - we can get
1249 this from the symbol value which has been zapped
1250 into the symbol index in the table when the
1251 symbol table was written
1252 */
1253 *dst++ = p->value >> 8;
1254 *dst++ = p->value;
1255 }
1256 }
1257 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
1258 /* relocations never occur from an unloadable section,
1259 so we can assume that raw_data is not NULL
1260 */
1261 *dst++ = *raw_data++;
1262 ADVANCE
1263 * dst++ = *raw_data++;
1264 ADVANCE
1265 if (how->size == 2)
1266 {
1267 *dst++ = *raw_data++;
1268 ADVANCE
1269 * dst++ = *raw_data++;
1270 ADVANCE
1271 }
1272 continue;
1273 }
1274 }
1275 /* If this is coming from an unloadable section then copy
1276 zeros */
1277 if (raw_data == NULL)
1278 {
1279 *dst++ = 0;
1280 }
1281 else
1282 {
1283 *dst++ = *raw_data++;
1284 }
1285 ADVANCE
1286 }
1287
1288 /* Don't write a useless null modification byte */
1289 if (dst == mod + 1)
1290 {
1291 --dst;
1292 }
1293
1294 if (! oasys_write_record (abfd,
1295 oasys_record_is_data_enum,
1296 ((oasys_record_union_type *)
1297 & processed_data),
1298 dst - (bfd_byte *) & processed_data))
1299 return false;
1300 }
1301 }
1302 }
1303
1304 return true;
1305 }
1306
1307 static boolean
1308 oasys_write_object_contents (abfd)
1309 bfd *abfd;
1310 {
1311 if (! oasys_write_header (abfd))
1312 return false;
1313 if (! oasys_write_syms (abfd))
1314 return false;
1315 if (! oasys_write_sections (abfd))
1316 return false;
1317 if (! oasys_write_data (abfd))
1318 return false;
1319 if (! oasys_write_end (abfd))
1320 return false;
1321 return true;
1322 }
1323
1324
1325
1326
1327 /** exec and core file sections */
1328
1329 /* set section contents is complicated with OASYS since the format is
1330 * not a byte image, but a record stream.
1331 */
1332 static boolean
1333 oasys_set_section_contents (abfd, section, location, offset, count)
1334 bfd *abfd;
1335 sec_ptr section;
1336 PTR location;
1337 file_ptr offset;
1338 bfd_size_type count;
1339 {
1340 if (count != 0)
1341 {
1342 if (oasys_per_section (section)->data == (bfd_byte *) NULL)
1343 {
1344 oasys_per_section (section)->data =
1345 (bfd_byte *) (bfd_alloc (abfd, section->_cooked_size));
1346 if (!oasys_per_section (section)->data)
1347 {
1348 bfd_set_error (bfd_error_no_memory);
1349 return false;
1350 }
1351 }
1352 (void) memcpy ((PTR) (oasys_per_section (section)->data + offset),
1353 location,
1354 count);
1355 }
1356 return true;
1357 }
1358
1359
1360
1361 /* Native-level interface to symbols. */
1362
1363 /* We read the symbols into a buffer, which is discarded when this
1364 function exits. We read the strings into a buffer large enough to
1365 hold them all plus all the cached symbol entries. */
1366
1367 static asymbol *
1368 oasys_make_empty_symbol (abfd)
1369 bfd *abfd;
1370 {
1371
1372 oasys_symbol_type *new =
1373 (oasys_symbol_type *) bfd_zalloc (abfd, sizeof (oasys_symbol_type));
1374 if (!new)
1375 {
1376 bfd_set_error (bfd_error_no_memory);
1377 return NULL;
1378 }
1379 new->symbol.the_bfd = abfd;
1380 return &new->symbol;
1381 }
1382 \f
1383
1384
1385
1386 /* User should have checked the file flags; perhaps we should return
1387 BFD_NO_MORE_SYMBOLS if there are none? */
1388
1389 static bfd *
1390 oasys_openr_next_archived_file (arch, prev)
1391 bfd *arch;
1392 bfd *prev;
1393 {
1394 oasys_ar_data_type *ar = OASYS_AR_DATA (arch);
1395 oasys_module_info_type *p;
1396 /* take the next one from the arch state, or reset */
1397 if (prev == (bfd *) NULL)
1398 {
1399 /* Reset the index - the first two entries are bogus*/
1400 ar->module_index = 0;
1401 }
1402
1403 p = ar->module + ar->module_index;
1404 ar->module_index++;
1405
1406 if (ar->module_index <= ar->module_count)
1407 {
1408 if (p->abfd == (bfd *) NULL)
1409 {
1410 p->abfd = _bfd_create_empty_archive_element_shell (arch);
1411 p->abfd->origin = p->pos;
1412 p->abfd->filename = p->name;
1413
1414 /* Fixup a pointer to this element for the member */
1415 p->abfd->arelt_data = (PTR) p;
1416 }
1417 return p->abfd;
1418 }
1419 else
1420 {
1421 bfd_set_error (bfd_error_no_more_archived_files);
1422 return (bfd *) NULL;
1423 }
1424 }
1425
1426 static boolean
1427 oasys_find_nearest_line (abfd,
1428 section,
1429 symbols,
1430 offset,
1431 filename_ptr,
1432 functionname_ptr,
1433 line_ptr)
1434 bfd *abfd;
1435 asection *section;
1436 asymbol **symbols;
1437 bfd_vma offset;
1438 char **filename_ptr;
1439 char **functionname_ptr;
1440 unsigned int *line_ptr;
1441 {
1442 return false;
1443
1444 }
1445
1446 static int
1447 oasys_generic_stat_arch_elt (abfd, buf)
1448 bfd *abfd;
1449 struct stat *buf;
1450 {
1451 oasys_module_info_type *mod = (oasys_module_info_type *) abfd->arelt_data;
1452 if (mod == (oasys_module_info_type *) NULL)
1453 {
1454 bfd_set_error (bfd_error_invalid_operation);
1455 return -1;
1456 }
1457 else
1458 {
1459 buf->st_size = mod->size;
1460 buf->st_mode = 0666;
1461 return 0;
1462 }
1463 }
1464
1465 static int
1466 oasys_sizeof_headers (abfd, exec)
1467 bfd *abfd;
1468 boolean exec;
1469 {
1470 return 0;
1471 }
1472
1473 #define oasys_close_and_cleanup _bfd_generic_close_and_cleanup
1474 #define oasys_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
1475
1476 #define oasys_slurp_armap bfd_true
1477 #define oasys_slurp_extended_name_table bfd_true
1478 #define oasys_truncate_arname bfd_dont_truncate_arname
1479 #define oasys_write_armap \
1480 ((boolean (*) \
1481 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int))) \
1482 bfd_true)
1483
1484 #define oasys_bfd_is_local_label bfd_generic_is_local_label
1485 #define oasys_get_lineno _bfd_nosymbols_get_lineno
1486 #define oasys_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
1487
1488 #define oasys_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
1489
1490 #define oasys_set_arch_mach bfd_default_set_arch_mach
1491
1492 #define oasys_bfd_get_relocated_section_contents \
1493 bfd_generic_get_relocated_section_contents
1494 #define oasys_bfd_relax_section bfd_generic_relax_section
1495 #define oasys_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
1496 #define oasys_bfd_link_add_symbols _bfd_generic_link_add_symbols
1497 #define oasys_bfd_final_link _bfd_generic_final_link
1498
1499 /*SUPPRESS 460 */
1500 const bfd_target oasys_vec =
1501 {
1502 "oasys", /* name */
1503 bfd_target_oasys_flavour,
1504 true, /* target byte order */
1505 true, /* target headers byte order */
1506 (HAS_RELOC | EXEC_P | /* object flags */
1507 HAS_LINENO | HAS_DEBUG |
1508 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
1509 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1510 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
1511 0, /* leading underscore */
1512 ' ', /* ar_pad_char */
1513 16, /* ar_max_namelen */
1514 1, /* minimum alignment */
1515 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1516 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1517 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */
1518 bfd_getb64, bfd_getb_signed_64, bfd_putb64,
1519 bfd_getb32, bfd_getb_signed_32, bfd_putb32,
1520 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */
1521
1522 {_bfd_dummy_target,
1523 oasys_object_p, /* bfd_check_format */
1524 oasys_archive_p,
1525 _bfd_dummy_target,
1526 },
1527 { /* bfd_set_format */
1528 bfd_false,
1529 oasys_mkobject,
1530 _bfd_generic_mkarchive,
1531 bfd_false
1532 },
1533 { /* bfd_write_contents */
1534 bfd_false,
1535 oasys_write_object_contents,
1536 _bfd_write_archive_contents,
1537 bfd_false,
1538 },
1539
1540 BFD_JUMP_TABLE_GENERIC (oasys),
1541 BFD_JUMP_TABLE_COPY (_bfd_generic),
1542 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1543 BFD_JUMP_TABLE_ARCHIVE (oasys),
1544 BFD_JUMP_TABLE_SYMBOLS (oasys),
1545 BFD_JUMP_TABLE_RELOCS (oasys),
1546 BFD_JUMP_TABLE_WRITE (oasys),
1547 BFD_JUMP_TABLE_LINK (oasys),
1548 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1549
1550 (PTR) 0
1551 };
GDB Binutils - Deliverables
This page took 0.07131 seconds and 5 git commands to generate.