]> Git Repo - binutils.git/blobdiff - bfd/elf.c
Make ld -N more reasonable for ELF:
[binutils.git] / bfd / elf.c
index 48762e16edd2b634810cfc958489264e01597087..6a27ba56dd743bf63c322c8542ae0c48514e884d 100644 (file)
--- a/bfd/elf.c
+++ b/bfd/elf.c
@@ -39,7 +39,7 @@ SECTION
 #include "elf-bfd.h"
 
 static INLINE struct elf_segment_map *make_mapping
-  PARAMS ((bfd *, asection **, unsigned int, unsigned int));
+  PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
 static int elf_sort_sections PARAMS ((const PTR, const PTR));
 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
@@ -554,8 +554,13 @@ _bfd_elf_link_hash_newfunc (entry, table, string)
       ret->weakdef = NULL;
       ret->got_offset = (bfd_vma) -1;
       ret->plt_offset = (bfd_vma) -1;
+      ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
       ret->type = STT_NOTYPE;
-      ret->elf_link_hash_flags = 0;
+      /* Assume that we have been called by a non-ELF symbol reader.
+         This flag is then reset by the code which reads an ELF input
+         file.  This ensures that a symbol created by a non-ELF symbol
+         reader will have the flag set correctly.  */
+      ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
     }
 
   return (struct bfd_hash_entry *) ret;
@@ -578,6 +583,8 @@ _bfd_elf_link_hash_table_init (table, abfd, newfunc)
   table->dynstr = NULL;
   table->bucketcount = 0;
   table->needed = NULL;
+  table->hgot = NULL;
+  table->stab_info = NULL;
   return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
 }
 
@@ -613,11 +620,13 @@ bfd_elf_set_dt_needed_name (abfd, name)
      bfd *abfd;
      const char *name;
 {
-  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
-    elf_dt_needed_name (abfd) = name;
+  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
+      && bfd_get_format (abfd) == bfd_object)
+    elf_dt_name (abfd) = name;
 }
 
-/* Get the list of DT_NEEDED entries for a link.  */
+/* Get the list of DT_NEEDED entries for a link.  This is a hook for
+   the ELF emulation code.  */
 
 struct bfd_link_needed_list *
 bfd_elf_get_needed_list (abfd, info)
@@ -628,6 +637,20 @@ bfd_elf_get_needed_list (abfd, info)
     return NULL;
   return elf_hash_table (info)->needed;
 }
+
+/* Get the name actually used for a dynamic object for a link.  This
+   is the SONAME entry if there is one.  Otherwise, it is the string
+   passed to bfd_elf_set_dt_needed_name, or it is the filename.  */
+
+const char *
+bfd_elf_get_dt_soname (abfd)
+     bfd *abfd;
+{
+  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
+      && bfd_get_format (abfd) == bfd_object)
+    return elf_dt_name (abfd);
+  return NULL;
+}
 \f
 /* Allocate an ELF string table--force the first byte to be zero.  */
 
@@ -778,7 +801,6 @@ bfd_section_from_shdr (abfd, shindex)
       {
        asection *target_sect;
        Elf_Internal_Shdr *hdr2;
-       int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
 
        /* For some incomprehensible reason Oracle distributes
           libraries for Solaris in which some of the objects have
@@ -823,30 +845,24 @@ bfd_section_from_shdr (abfd, shindex)
        if (hdr->sh_link != elf_onesymtab (abfd))
          return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
 
-       /* Don't allow REL relocations on a machine that uses RELA and
-          vice versa.  */
-       /* @@ Actually, the generic ABI does suggest that both might be
-          used in one file.  But the four ABI Processor Supplements I
-          have access to right now all specify that only one is used on
-          each of those architectures.  It's conceivable that, e.g., a
-          bunch of absolute 32-bit relocs might be more compact in REL
-          form even on a RELA machine...  */
-       BFD_ASSERT (use_rela_p
-                   ? (hdr->sh_type == SHT_RELA
-                      && hdr->sh_entsize == bed->s->sizeof_rela)
-                   : (hdr->sh_type == SHT_REL
-                      && hdr->sh_entsize == bed->s->sizeof_rel));
-
        if (! bfd_section_from_shdr (abfd, hdr->sh_info))
          return false;
        target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
        if (target_sect == NULL)
          return false;
 
-       hdr2 = &elf_section_data (target_sect)->rel_hdr;
+       if ((target_sect->flags & SEC_RELOC) == 0
+           || target_sect->reloc_count == 0)
+         hdr2 = &elf_section_data (target_sect)->rel_hdr;
+       else
+         {
+           BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
+           hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
+           elf_section_data (target_sect)->rel_hdr2 = hdr2;
+         }
        *hdr2 = *hdr;
        elf_elfsections (abfd)[shindex] = hdr2;
-       target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
+       target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
        target_sect->flags |= SEC_RELOC;
        target_sect->relocation = NULL;
        target_sect->rel_filepos = hdr->sh_offset;
@@ -1023,7 +1039,8 @@ elf_fake_sections (abfd, asect, failedptrarg)
 
   this_hdr->sh_flags = 0;
 
-  if ((asect->flags & SEC_ALLOC) != 0)
+  if ((asect->flags & SEC_ALLOC) != 0
+      || asect->user_set_vma)
     this_hdr->sh_addr = asect->vma;
   else
     this_hdr->sh_addr = 0;
@@ -1587,11 +1604,12 @@ _bfd_elf_compute_section_file_positions (abfd, link_info)
 /* Create a mapping from a set of sections to a program segment.  */
 
 static INLINE struct elf_segment_map *
-make_mapping (abfd, sections, from, to)
+make_mapping (abfd, sections, from, to, phdr)
      bfd *abfd;
      asection **sections;
      unsigned int from;
      unsigned int to;
+     boolean phdr;
 {
   struct elf_segment_map *m;
   unsigned int i;
@@ -1609,7 +1627,7 @@ make_mapping (abfd, sections, from, to)
     m->sections[i - from] = *hdrpp;
   m->count = to - from;
 
-  if (from == 0)
+  if (from == 0 && phdr)
     {
       /* Include the headers in the first PT_LOAD segment.  */
       m->includes_filehdr = 1;
@@ -1636,6 +1654,9 @@ map_sections_to_segments (abfd)
   unsigned int phdr_index;
   bfd_vma maxpagesize;
   asection **hdrpp;
+  boolean phdr_in_section = true;
+  boolean writable;
+  asection *dynsec;
 
   if (elf_tdata (abfd)->segment_map != NULL)
     return true;
@@ -1708,6 +1729,28 @@ map_sections_to_segments (abfd)
   last_hdr = NULL;
   phdr_index = 0;
   maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
+  writable = false;
+  dynsec = bfd_get_section_by_name (abfd, ".dynamic");
+  if (dynsec != NULL
+      && (dynsec->flags & SEC_LOAD) == 0)
+    dynsec = NULL;
+
+  /* Deal with -Ttext or something similar such that the first section
+     is not adjacent to the program headers.  This is an
+     approximation, since at this point we don't know exactly how many
+     program headers we will need.  */
+  if (count > 0)
+    {
+      bfd_size_type phdr_size;
+
+      phdr_size = elf_tdata (abfd)->program_header_size;
+      if (phdr_size == 0)
+       phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
+      if ((abfd->flags & D_PAGED) == 0
+         || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
+       phdr_in_section = false;
+    }
+
   for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
     {
       asection *hdr;
@@ -1715,13 +1758,28 @@ map_sections_to_segments (abfd)
       hdr = *hdrpp;
 
       /* See if this section and the last one will fit in the same
-         segment.  */
+         segment.  Don't put a loadable section after a non-loadable
+         section.  If we are building a dynamic executable, don't put
+         a writable section in a read only segment, unless they're on
+         the same page anyhow (we don't do this for a non-dynamic
+         executable because some people prefer to have only one
+         program segment; anybody can use PHDRS in their linker script
+         to control what happens anyhow).  */
       if (last_hdr == NULL
+         || (abfd->flags & D_PAGED) == 0
          || ((BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
               >= hdr->lma)
              && ((last_hdr->flags & SEC_LOAD) != 0
-                 || (hdr->flags & SEC_LOAD) == 0)))
+                 || (hdr->flags & SEC_LOAD) == 0)
+             && (dynsec == NULL
+                 || writable
+                 || (hdr->flags & SEC_READONLY) != 0
+                 || (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size,
+                                maxpagesize)
+                     > hdr->lma))))
        {
+         if ((hdr->flags & SEC_READONLY) == 0)
+           writable = true;
          last_hdr = hdr;
          continue;
        }
@@ -1730,21 +1788,27 @@ map_sections_to_segments (abfd)
          create a new program header holding all the sections from
          phdr_index until hdr.  */
 
-      m = make_mapping (abfd, sections, phdr_index, i);
+      m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section);
       if (m == NULL)
        goto error_return;
 
       *pm = m;
       pm = &m->next;
 
+      if ((hdr->flags & SEC_READONLY) == 0)
+       writable = true;
+      else
+       writable = false;
+
       last_hdr = hdr;
       phdr_index = i;
+      phdr_in_section = false;
     }
 
   /* Create a final PT_LOAD program segment.  */
   if (last_hdr != NULL)
     {
-      m = make_mapping (abfd, sections, phdr_index, i);
+      m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section);
       if (m == NULL)
        goto error_return;
 
@@ -1753,8 +1817,7 @@ map_sections_to_segments (abfd)
     }
 
   /* If there is a .dynamic section, throw in a PT_DYNAMIC segment.  */
-  s = bfd_get_section_by_name (abfd, ".dynamic");
-  if (s != NULL && (s->flags & SEC_LOAD) != 0)
+  if (dynsec != NULL)
     {
       m = ((struct elf_segment_map *)
           bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
@@ -1763,7 +1826,7 @@ map_sections_to_segments (abfd)
       m->next = NULL;
       m->p_type = PT_DYNAMIC;
       m->count = 1;
-      m->sections[0] = s;
+      m->sections[0] = dynsec;
 
       *pm = m;
       pm = &m->next;
@@ -1796,6 +1859,13 @@ elf_sort_sections (arg1, arg2)
   else if (sec1->vma > sec2->vma)
     return 1;
 
+  /* Sort by LMA.  Normally the LMA and the VMA will be the same, and
+     this will do nothing.  */
+  if (sec1->lma < sec2->lma)
+    return -1;
+  else if (sec1->lma > sec2->lma)
+    return 1;
+
   /* Put !SEC_LOAD sections after SEC_LOAD ones.  */
 
 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
@@ -1835,7 +1905,7 @@ assign_file_positions_for_segments (abfd)
   struct elf_segment_map *m;
   unsigned int alloc;
   Elf_Internal_Phdr *phdrs;
-  file_ptr off;
+  file_ptr off, voff;
   bfd_vma filehdr_vaddr, filehdr_paddr;
   bfd_vma phdrs_vaddr, phdrs_paddr;
   Elf_Internal_Phdr *p;
@@ -1911,8 +1981,16 @@ assign_file_positions_for_segments (abfd)
       else
        p->p_flags = 0;
 
-      if (p->p_type == PT_LOAD && m->count > 0)
-       off += (m->sections[0]->vma - off) % bed->maxpagesize;
+      if (p->p_type == PT_LOAD
+         && m->count > 0
+         && (m->sections[0]->flags & SEC_LOAD) != 0)
+       {
+         if ((abfd->flags & D_PAGED) != 0)
+           off += (m->sections[0]->vma - off) % bed->maxpagesize;
+         else
+           off += ((m->sections[0]->vma - off)
+                   % (1 << bfd_get_section_alignment (abfd, m->sections[0])));
+       }
 
       if (m->count == 0)
        p->p_vaddr = 0;
@@ -1926,7 +2004,8 @@ assign_file_positions_for_segments (abfd)
       else
        p->p_paddr = m->sections[0]->lma;
 
-      if (p->p_type == PT_LOAD)
+      if (p->p_type == PT_LOAD
+         && (abfd->flags & D_PAGED) != 0)
        p->p_align = bed->maxpagesize;
       else if (m->count == 0)
        p->p_align = bed->s->file_align;
@@ -2004,6 +2083,7 @@ assign_file_positions_for_segments (abfd)
            }
        }
 
+      voff = off;
       for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
        {
          asection *sec;
@@ -2012,6 +2092,7 @@ assign_file_positions_for_segments (abfd)
 
          sec = *secpp;
          flags = sec->flags;
+         align = 1 << bfd_get_section_alignment (abfd, sec);
 
          if (p->p_type == PT_LOAD)
            {
@@ -2019,21 +2100,30 @@ assign_file_positions_for_segments (abfd)
 
              /* The section VMA must equal the file position modulo
                  the page size.  */
-             adjust = (sec->vma - off) % bed->maxpagesize;
-             if (adjust != 0)
+             if ((flags & SEC_ALLOC) != 0)
                {
-                 if (i == 0)
-                   abort ();
-                 p->p_memsz += adjust;
-                 if ((flags & SEC_LOAD) != 0)
-                   p->p_filesz += adjust;
-                 off += adjust;
+                 if ((abfd->flags & D_PAGED) != 0)
+                   adjust = (sec->vma - voff) % bed->maxpagesize;
+                 else
+                   adjust = (sec->vma - voff) % align;
+                 if (adjust != 0)
+                   {
+                     if (i == 0)
+                       abort ();
+                     p->p_memsz += adjust;
+                     off += adjust;
+                     voff += adjust;
+                     if ((flags & SEC_LOAD) != 0)
+                       p->p_filesz += adjust;
+                   }
                }
 
              sec->filepos = off;
 
              if ((flags & SEC_LOAD) != 0)
                off += sec->_raw_size;
+             if ((flags & SEC_ALLOC) != 0)
+               voff += sec->_raw_size;
            }
 
          p->p_memsz += sec->_raw_size;
@@ -2041,7 +2131,6 @@ assign_file_positions_for_segments (abfd)
          if ((flags & SEC_LOAD) != 0)
            p->p_filesz += sec->_raw_size;
 
-         align = 1 << bfd_get_section_alignment (abfd, sec);
          if (align > p->p_align)
            p->p_align = align;
 
@@ -2253,7 +2342,10 @@ assign_file_positions_except_relocs (abfd)
                (hdr->bfd_section == NULL
                 ? "*unknown*"
                 : hdr->bfd_section->name)));
-             off += (hdr->sh_addr - off) % bed->maxpagesize;
+             if ((abfd->flags & D_PAGED) != 0)
+               off += (hdr->sh_addr - off) % bed->maxpagesize;
+             else
+               off += (hdr->sh_addr - off) % hdr->sh_addralign;
              off = _bfd_elf_assign_file_position_for_section (hdr, off,
                                                               false);
            }
@@ -2349,6 +2441,14 @@ prep_headers (abfd)
     case bfd_arch_powerpc:
       i_ehdrp->e_machine = EM_PPC;
       break;
+    case bfd_arch_alpha:
+      i_ehdrp->e_machine = EM_ALPHA;
+      break;
+/* start-sanitize-d10v */
+    case bfd_arch_d10v:
+      i_ehdrp->e_machine = EM_CYGNUS_D10V;
+      break;
+/* end-sanitize-d10v */
 /* start-sanitize-arc */
     case bfd_arch_arc:
       i_ehdrp->e_machine = EM_CYGNUS_ARC;
@@ -2527,13 +2627,15 @@ _bfd_elf_section_from_bfd_section (abfd, asect)
   return -1;
 }
 
-/* given a symbol, return the bfd index for that symbol.  */
- int
+/* Given a BFD symbol, return the index in the ELF symbol table, or -1
+   on error.  */
+
+int
 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
      bfd *abfd;
-     struct symbol_cache_entry **asym_ptr_ptr;
+     asymbol **asym_ptr_ptr;
 {
-  struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
+  asymbol *asym_ptr = *asym_ptr_ptr;
   int idx;
   flagword flags = asym_ptr->flags;
 
@@ -2557,13 +2659,24 @@ _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
     }
 
   idx = asym_ptr->udata.i;
-  BFD_ASSERT (idx != 0);
+
+  if (idx == 0)
+    {
+      /* This case can occur when using --strip-symbol on a symbol
+         which is used in a relocation entry.  */
+      (*_bfd_error_handler)
+       ("%s: symbol `%s' required but not present",
+        bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
+      bfd_set_error (bfd_error_no_symbols);
+      return -1;
+    }
 
 #if DEBUG & 4
   {
     fprintf (stderr,
             "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
-     (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
+            (long) asym_ptr, asym_ptr->name, idx, flags,
+            elf_symbol_flags (flags));
     fflush (stderr);
   }
 #endif
@@ -2831,6 +2944,7 @@ swap_out_syms (abfd, sttp)
        bfd_vma value = syms[idx]->value;
        elf_symbol_type *type_ptr;
        flagword flags = syms[idx]->flags;
+       int type;
 
        if (flags & BSF_SECTION_SYM)
          /* Section symbols have no names.  */
@@ -2925,15 +3039,20 @@ swap_out_syms (abfd, sttp)
            sym.st_shndx = shndx;
          }
 
+       if ((flags & BSF_FUNCTION) != 0)
+         type = STT_FUNC;
+       else if ((flags & BSF_OBJECT) != 0)
+         type = STT_OBJECT;
+       else
+         type = STT_NOTYPE;
+
        if (bfd_is_com_section (syms[idx]->section))
-         sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_OBJECT);
+         sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
        else if (bfd_is_und_section (syms[idx]->section))
          sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
                                      ? STB_WEAK
                                      : STB_GLOBAL),
-                                    ((flags & BSF_FUNCTION)
-                                     ? STT_FUNC
-                                     : STT_NOTYPE));
+                                    type);
        else if (flags & BSF_SECTION_SYM)
          sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
        else if (flags & BSF_FILE)
@@ -2941,7 +3060,6 @@ swap_out_syms (abfd, sttp)
        else
          {
            int bind = STB_LOCAL;
-           int type = STT_OBJECT;
 
            if (flags & BSF_LOCAL)
              bind = STB_LOCAL;
@@ -2950,9 +3068,6 @@ swap_out_syms (abfd, sttp)
            else if (flags & BSF_GLOBAL)
              bind = STB_GLOBAL;
 
-           if (flags & BSF_FUNCTION)
-             type = STT_FUNC;
-
            sym.st_info = ELF_ST_INFO (bind, type);
          }
 
@@ -3137,15 +3252,26 @@ _bfd_elf_find_nearest_line (abfd,
      CONST char **functionname_ptr;
      unsigned int *line_ptr;
 {
+  boolean found;
   const char *filename;
   asymbol *func;
+  bfd_vma low_func;
   asymbol **p;
 
+  if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
+                                            &found, filename_ptr,
+                                            functionname_ptr, line_ptr,
+                                            &elf_tdata (abfd)->line_info))
+    return false;
+  if (found)
+    return true;
+
   if (symbols == NULL)
     return false;
 
   filename = NULL;
   func = NULL;
+  low_func = 0;
 
   for (p = symbols; *p != NULL; p++)
     {
@@ -3164,9 +3290,13 @@ _bfd_elf_find_nearest_line (abfd,
          filename = bfd_asymbol_name (&q->symbol);
          break;
        case STT_FUNC:
-         if (func == NULL
-             || q->symbol.value <= offset)
-           func = (asymbol *) q;
+         if (q->symbol.section == section
+             && q->symbol.value >= low_func
+             && q->symbol.value <= offset)
+           {
+             func = (asymbol *) q;
+             low_func = q->symbol.value;
+           }
          break;
        }
     }
@@ -3237,3 +3367,101 @@ _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
   abort ();
 }
 #endif
+
+/* Try to convert a non-ELF reloc into an ELF one.  */
+
+boolean
+_bfd_elf_validate_reloc (abfd, areloc)
+     bfd *abfd;
+     arelent *areloc;
+{
+  /* Check whether we really have an ELF howto. */
+
+  if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 
+    {
+      bfd_reloc_code_real_type code;
+      reloc_howto_type *howto;
+      
+      /* Alien reloc: Try to determine its type to replace it with an
+        equivalent ELF reloc. */
+
+      if (areloc->howto->pc_relative)
+       {
+         switch (areloc->howto->bitsize)
+           {
+           case 8:
+             code = BFD_RELOC_8_PCREL; 
+             break;
+           case 12:
+             code = BFD_RELOC_12_PCREL; 
+             break;
+           case 16:
+             code = BFD_RELOC_16_PCREL; 
+             break;
+           case 24:
+             code = BFD_RELOC_24_PCREL; 
+             break;
+           case 32:
+             code = BFD_RELOC_32_PCREL; 
+             break;
+           case 64:
+             code = BFD_RELOC_64_PCREL; 
+             break;
+           default:
+             goto fail;
+           }
+
+         howto = bfd_reloc_type_lookup (abfd, code);
+
+         if (areloc->howto->pcrel_offset != howto->pcrel_offset)
+           {
+             if (howto->pcrel_offset)
+               areloc->addend += areloc->address;
+             else
+               areloc->addend -= areloc->address; /* addend is unsigned!! */
+           }
+       }
+      else
+       {
+         switch (areloc->howto->bitsize)
+           {
+           case 8:
+             code = BFD_RELOC_8; 
+             break;
+           case 14:
+             code = BFD_RELOC_14; 
+             break;
+           case 16:
+             code = BFD_RELOC_16; 
+             break;
+           case 26:
+             code = BFD_RELOC_26; 
+             break;
+           case 32:
+             code = BFD_RELOC_32; 
+             break;
+           case 64:
+             code = BFD_RELOC_64; 
+             break;
+           default:
+             goto fail;
+           }
+
+         howto = bfd_reloc_type_lookup (abfd, code);
+       }
+
+      if (howto)
+       areloc->howto = howto;
+      else
+       goto fail;
+    }
+
+  return true;
+
+ fail:
+  (*_bfd_error_handler)
+    ("%s: unsupported relocation type %s",
+     bfd_get_filename (abfd), areloc->howto->name);
+  bfd_set_error (bfd_error_bad_value);
+  return false;
+}
This page took 0.043092 seconds and 4 git commands to generate.