Re: [PATCH v4] elf/x86-64: Subtract __ImageBase for R_AMD64_IMAGEBASE

["H.J. Lu" <hjl.tools@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 6573 bytes --]

On Thu, Mar 4, 2021 at 9:17 PM Alan Modra <amodra@gmail.com> wrote:
>
> On Thu, Mar 04, 2021 at 05:54:20AM -0800, H.J. Lu wrote:
> > Here is the v4 patch on top of yours.
>
> No patch?
>
> This is what I'm about to commit, now rather than in a week's time
> since you seem happy with it.  Changes from the previous patch are:
>  - removed test of ELF output, the fixes are generic
>  - untangled and corrected pc-relative adjustment to use
>    bfd_get_reloc_size
>
> There are some further obvious fixes to make as noted in the commit
> log, but I'll leave that to someone with better access to PE
> compilers.
>
> ----
> Subject: Move x86_64 PE changes out of bfd_perform_relocation
>
> bfd_perform_relocation should not have special case target code.  This
> patch moves the code that was there for x86_64 PE linking to ELF
> output into the x86_64 PE howto special function, correcting that
> function for linking to targets other than ELF too.  The fixes in
> bfd_perform_relocation were over-complicated due to needing to
> compensate for things that had already gone wrong in coff_amd64_reloc.
> In particular, an adjustment for pc-relative relocs was done in a way
> that meant adjustment for things related to symbol offsets was lost.
> I think those two things are orthogonal, but who knows with COFF where
> addends and symbol values are found randomly in the section contents.
>
> Note that linking natively to an x86_64 PE output relocates by
> coff_pe_amd64_relocate_section, which does not use arelent relocs or
> bfd_perform_relocation, but be aware of coff_amd64_rtype_to_howto
> hacking addends for relocations.  The adjustments for a particular
> relocation type there and in coff_amd64_reloc ought to match after
> taking into consideration CALC_ADDEND.  They don't.  For example,
> the pc-relative adjustment for R_PCRWORD is 2 bytes in
> coff_amd64_reloc and 4 bytes in coff_amd64_rtype_to_howto.
>
>         * reloc.c (bfd_perform_relocation): Revert 2021-01-12 and
>         2020-09-16 changes.
>         * coff-x86_64.c (coff_amd64_reloc): Do more or less the same
>         adjustments here instead.  Separate pc-relative adjustments
>         from symbol related adjustments.  Tidy comments and formatting.
>
> diff --git a/bfd/coff-x86_64.c b/bfd/coff-x86_64.c
> index adab60cd11..5b09023f3c 100644
> --- a/bfd/coff-x86_64.c
> +++ b/bfd/coff-x86_64.c
> @@ -75,14 +75,14 @@ coff_amd64_reloc (bfd *abfd,
>  {
>    symvalue diff;
>
> -#if !defined(COFF_WITH_PE)
> +#if !defined (COFF_WITH_PE)
>    if (output_bfd == NULL)
>      return bfd_reloc_continue;
>  #endif
>
>    if (bfd_is_com_section (symbol->section))
>      {
> -#if !defined(COFF_WITH_PE)
> +#if !defined (COFF_WITH_PE)
>        /* We are relocating a common symbol.  The current value in the
>          object file is ORIG + OFFSET, where ORIG is the value of the
>          common symbol as seen by the object file when it was compiled
> @@ -106,21 +106,10 @@ coff_amd64_reloc (bfd *abfd,
>          ignores the addend for a COFF target when producing
>          relocatable output.  This seems to be always wrong for 386
>          COFF, so we handle the addend here instead.  */
> -#if defined(COFF_WITH_PE)
> +#if defined (COFF_WITH_PE)
>        if (output_bfd == NULL)
>         {
> -         reloc_howto_type *howto = reloc_entry->howto;
> -
> -         /* Although PC relative relocations are very similar between
> -            PE and non-PE formats, but they are off by 1 << howto->size
> -            bytes. For the external relocation, PE is very different
> -            from others. See md_apply_fix3 () in gas/config/tc-amd64.c.
> -            When we link PE and non-PE object files together to
> -            generate a non-PE executable, we have to compensate it
> -            here.  */
> -         if(howto->pc_relative && howto->pcrel_offset)
> -           diff = -(1 << howto->size);
> -         else if(symbol->flags & BSF_WEAK)
> +         if (symbol->flags & BSF_WEAK)
>             diff = reloc_entry->addend - symbol->value;
>           else
>             diff = -reloc_entry->addend;
> @@ -130,7 +119,18 @@ coff_amd64_reloc (bfd *abfd,
>         diff = reloc_entry->addend;
>      }
>
> -#if defined(COFF_WITH_PE)
> +#if defined (COFF_WITH_PE)
> +  if (output_bfd == NULL)
> +    {
> +      /* PC relative relocations are off by their size.  */
> +      if (reloc_entry->howto->pc_relative)
> +       diff -= bfd_get_reloc_size (reloc_entry->howto);
> +
> +      if (reloc_entry->howto->type >= R_AMD64_PCRLONG_1
> +         && reloc_entry->howto->type <= R_AMD64_PCRLONG_5)
> +       diff -= reloc_entry->howto->type - R_AMD64_PCRLONG;
> +    }
> +
>    /* FIXME: How should this case be handled?  */
>    if (reloc_entry->howto->type == R_AMD64_IMAGEBASE
>        && output_bfd != NULL
> diff --git a/bfd/reloc.c b/bfd/reloc.c
> index a7547187eb..5ed7bb8e59 100644
> --- a/bfd/reloc.c
> +++ b/bfd/reloc.c
> @@ -51,7 +51,7 @@ SECTION
>  #include "bfdlink.h"
>  #include "libbfd.h"
>  #include "bfdver.h"
> -#include "coff/x86_64.h"
> +
>  /*
>  DOCDD
>  INODE
> @@ -905,30 +905,6 @@ space consuming.  For each target:
>             }
>         }
>      }
> -  else if (abfd->xvec->flavour == bfd_target_coff_flavour
> -          && (input_section->output_section->owner->xvec->flavour
> -              == bfd_target_elf_flavour)
> -          && strcmp (abfd->xvec->name, "pe-x86-64") == 0
> -          && strcmp (input_section->output_section->owner->xvec->name,
> -                     "elf64-x86-64") == 0)
> -    {
> -      /* NB: bfd_perform_relocation isn't called to generate PE binary.
> -        _bfd_relocate_contents is called instead.  When linking PE
> -        object files to generate ELF output, _bfd_relocate_contents
> -        isn't called and bfd_perform_relocation is used.  We need to
> -        adjust relocation here.  */
> -      relocation -= reloc_entry->addend;
> -      if (howto->type >= R_AMD64_PCRLONG_1
> -         && howto->type <= R_AMD64_PCRLONG_5)
> -       relocation -= (bfd_vma)(howto->type - R_AMD64_PCRLONG);
> -      else if (howto->type == R_AMD64_DIR64
> -              || howto->type == R_AMD64_DIR32)
> -       {
> -         bfd_vma val = read_reloc (abfd, (bfd_byte *) data + octets,
> -                                   howto);
> -         relocation -= val & howto->src_mask;
> -       }
> -    }
>
>    /* FIXME: This overflow checking is incomplete, because the value
>       might have overflowed before we get here.  For a correct check we
>

Here is the v4 patch.  OK for master?

Thanks.

-- 
H.J.

[-- Attachment #2: v4-0001-elf-x86-64-Subtract-__ImageBase-for-R_AMD64_IMAGE.patch --]
[-- Type: text/x-patch, Size: 19560 bytes --]

From 5d2172fe937794079721186041538d3bdb0e3ac2 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Mon, 15 Feb 2021 18:53:18 -0800
Subject: [PATCH v4] elf/x86-64: Subtract __ImageBase for R_AMD64_IMAGEBASE

When linking Windows x86-64 relocatable object files to generate x86-64
ELF executable, we need to subtract __ImageBase, aka __executable_start,
for R_AMD64_IMAGEBASE relocation.

1. Add link_info to struct output_elf_obj_tdata to store optional linker
information and _bfd_get_link_info() to retrieve it.
2. Set link_info up in _bfd_elf_linker_x86_set_options.
3. Create an indirect reference to __executable_start for __ImageBase to
support R_AMD64_IMAGEBASE relocation when seeing Windows x86-64 relocatable
object files.
4. Subtract __ImageBase for R_AMD64_IMAGEBASE in R_AMD64_IMAGEBASE.

bfd/

	PR ld/27425
	PR ld/27432
	* bfd.c (_bfd_get_link_info): New function.
	* elf-bfd.h (output_elf_obj_tdata): Add link_info.
	(elf_link_info): New.
	* elfxx-x86.c (_bfd_elf_linker_x86_set_options): Set up link_info.
	* libbfd-in.h (_bfd_get_link_info): New prototype.
	* coff-x86_64.c (coff_amd64_reloc): Subtract __ImageBase for
	R_AMD64_IMAGEBASE.
	* libbfd.h: Regenerated.

ld/

	PR ld/27425
	PR ld/27432
	* ldelf.c (ldelf_load_symbols): Create an indirect reference to
	__executable_start for __ImageBase to support R_AMD64_IMAGEBASE
	relocation when seeing Windows x86-64 relocatable inputs.
	* ld-x86-64/pe-x86-64-1.od: Expect __executable_start.
	* testsuite/ld-x86-64/pe-x86-64-2.od: Likewise.
	* testsuite/ld-x86-64/pe-x86-64-3.od: Likewise.
	* testsuite/ld-x86-64/pe-x86-64-4.od: Likewise.
	* testsuite/ld-x86-64/pe-x86-64-5.od: Likewise.
	* testsuite/ld-x86-64/pe-x86-64-5.rd: Likewise.
	* testsuite/ld-x86-64/pe-x86-64-6.obj.bz2: New file.
	* testsuite/ld-x86-64/pe-x86-64-6.od: Likewise.
	* testsuite/ld-x86-64/pe-x86-64.exp: Run ld/27425 test.
---
 bfd/bfd.c                                  |  11 +++
 bfd/coff-x86_64.c                          |  38 +++++++--
 bfd/elf-bfd.h                              |   4 +
 bfd/elfxx-x86.c                            |   2 +
 bfd/libbfd-in.h                            |   2 +
 bfd/libbfd.h                               |   2 +
 ld/ldelf.c                                 |  24 ++++++
 ld/testsuite/ld-x86-64/pe-x86-64-1.od      |   1 +
 ld/testsuite/ld-x86-64/pe-x86-64-2.od      |   1 +
 ld/testsuite/ld-x86-64/pe-x86-64-3.od      |   1 +
 ld/testsuite/ld-x86-64/pe-x86-64-4.od      |   1 +
 ld/testsuite/ld-x86-64/pe-x86-64-5.od      |   1 +
 ld/testsuite/ld-x86-64/pe-x86-64-5.rd      |   3 +-
 ld/testsuite/ld-x86-64/pe-x86-64-6.obj.bz2 | Bin 0 -> 1366 bytes
 ld/testsuite/ld-x86-64/pe-x86-64-6.od      |  91 +++++++++++++++++++++
 ld/testsuite/ld-x86-64/pe-x86-64.exp       |   9 ++
 16 files changed, 184 insertions(+), 7 deletions(-)
 create mode 100644 ld/testsuite/ld-x86-64/pe-x86-64-6.obj.bz2
 create mode 100644 ld/testsuite/ld-x86-64/pe-x86-64-6.od

diff --git a/bfd/bfd.c b/bfd/bfd.c
index f1944338838..2cf7b47bca1 100644
--- a/bfd/bfd.c
+++ b/bfd/bfd.c
@@ -2808,3 +2808,14 @@ bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
   *ptr_size = size;
   return TRUE;
 }
+
+/* Get the optional linker information.  */
+
+struct bfd_link_info *
+_bfd_get_link_info (bfd *abfd)
+{
+  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+    return NULL;
+
+  return elf_link_info (abfd);
+}
diff --git a/bfd/coff-x86_64.c b/bfd/coff-x86_64.c
index 5b09023f3c2..be20da165d9 100644
--- a/bfd/coff-x86_64.c
+++ b/bfd/coff-x86_64.c
@@ -122,13 +122,39 @@ coff_amd64_reloc (bfd *abfd,
 #if defined (COFF_WITH_PE)
   if (output_bfd == NULL)
     {
-      /* PC relative relocations are off by their size.  */
-      if (reloc_entry->howto->pc_relative)
-	diff -= bfd_get_reloc_size (reloc_entry->howto);
+      if ((bfd_get_flavour (input_section->output_section->owner)
+	   == bfd_target_elf_flavour)
+	  && reloc_entry->howto->type == R_AMD64_IMAGEBASE)
+	{
+	  /* Subtract __ImageBase.  */
+	  struct bfd_link_info *link_info;
+	  struct bfd_link_hash_entry *h;
+	  link_info
+	    = _bfd_get_link_info (input_section->output_section->owner);
+	  if (link_info == NULL)
+	    abort ();
+	  h = bfd_link_hash_lookup (link_info->hash, "__ImageBase",
+				    FALSE, FALSE, FALSE);
+	  if (h == NULL)
+	    abort ();
+	  while (h->type == bfd_link_hash_indirect)
+	    h = h->u.i.link;
+	  /* ELF symbols in relocatable files are section relative,
+	     but in nonrelocatable files they are virtual addresses.  */
+	  diff -= (h->u.def.value
+		   + h->u.def.section->output_offset
+		   + h->u.def.section->output_section->vma);
+	}
+      else
+	{
+	  /* PC relative relocations are off by their size.  */
+	  if (reloc_entry->howto->pc_relative)
+	    diff -= bfd_get_reloc_size (reloc_entry->howto);
 
-      if (reloc_entry->howto->type >= R_AMD64_PCRLONG_1
-	  && reloc_entry->howto->type <= R_AMD64_PCRLONG_5)
-	diff -= reloc_entry->howto->type - R_AMD64_PCRLONG;
+	  if (reloc_entry->howto->type >= R_AMD64_PCRLONG_1
+	      && reloc_entry->howto->type <= R_AMD64_PCRLONG_5)
+	    diff -= reloc_entry->howto->type - R_AMD64_PCRLONG;
+	}
     }
 
   /* FIXME: How should this case be handled?  */
diff --git a/bfd/elf-bfd.h b/bfd/elf-bfd.h
index dd66d98883e..c2aaab0e5bf 100644
--- a/bfd/elf-bfd.h
+++ b/bfd/elf-bfd.h
@@ -1887,6 +1887,9 @@ struct output_elf_obj_tdata
   /* Used when laying out sections.  */
   file_ptr next_file_pos;
 
+  /* Optional linker information.  */
+  struct bfd_link_info *link_info;
+
   int num_section_syms;
   unsigned int shstrtab_section, strtab_section;
 
@@ -2064,6 +2067,7 @@ struct elf_obj_tdata
 #define elf_elfsections(bfd)	(elf_tdata(bfd) -> elf_sect_ptr)
 #define elf_numsections(bfd)	(elf_tdata(bfd) -> num_elf_sections)
 #define elf_seg_map(bfd)	(elf_tdata(bfd) -> o->seg_map)
+#define elf_link_info(bfd)	(elf_tdata(bfd) -> o->link_info)
 #define elf_next_file_pos(bfd)	(elf_tdata(bfd) -> o->next_file_pos)
 #define elf_eh_frame_hdr(bfd)	(elf_tdata(bfd) -> o->eh_frame_hdr)
 #define elf_stack_flags(bfd)	(elf_tdata(bfd) -> o->stack_flags)
diff --git a/bfd/elfxx-x86.c b/bfd/elfxx-x86.c
index 93ad38c5eb0..e60d87ff981 100644
--- a/bfd/elfxx-x86.c
+++ b/bfd/elfxx-x86.c
@@ -3174,6 +3174,8 @@ _bfd_elf_linker_x86_set_options (struct bfd_link_info * info,
     = get_elf_backend_data (info->output_bfd);
   struct elf_x86_link_hash_table *htab
     = elf_x86_hash_table (info, bed->target_id);
+  if (info->output_bfd->xvec->flavour == bfd_target_elf_flavour)
+    elf_link_info (info->output_bfd) = info;
   if (htab != NULL)
     htab->params = params;
 }
diff --git a/bfd/libbfd-in.h b/bfd/libbfd-in.h
index 2dc20ec1b19..62b1cee0af0 100644
--- a/bfd/libbfd-in.h
+++ b/bfd/libbfd-in.h
@@ -899,6 +899,8 @@ extern bfd_vma _bfd_safe_read_leb128
 extern bfd_byte * _bfd_write_unsigned_leb128
   (bfd_byte *, bfd_byte *, bfd_vma) ATTRIBUTE_HIDDEN;
 
+extern struct bfd_link_info *_bfd_get_link_info (bfd *);
+
 #if GCC_VERSION >= 7000
 #define _bfd_mul_overflow(a, b, res) __builtin_mul_overflow (a, b, res)
 #else
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index 7271a2ad5a1..3a481ea468f 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -904,6 +904,8 @@ extern bfd_vma _bfd_safe_read_leb128
 extern bfd_byte * _bfd_write_unsigned_leb128
   (bfd_byte *, bfd_byte *, bfd_vma) ATTRIBUTE_HIDDEN;
 
+extern struct bfd_link_info *_bfd_get_link_info (bfd *);
+
 #if GCC_VERSION >= 7000
 #define _bfd_mul_overflow(a, b, res) __builtin_mul_overflow (a, b, res)
 #else
diff --git a/ld/ldelf.c b/ld/ldelf.c
index 049992544a2..c7de958dbdc 100644
--- a/ld/ldelf.c
+++ b/ld/ldelf.c
@@ -81,6 +81,30 @@ ldelf_load_symbols (lang_input_statement_type *entry)
 {
   int link_class = 0;
 
+  if (bfd_link_pde (&link_info)
+      && entry->the_bfd->xvec->flavour == bfd_target_coff_flavour
+      && strcmp (entry->the_bfd->xvec->name, "pe-x86-64") == 0
+      && strcmp (link_info.output_bfd->xvec->name, "elf64-x86-64") == 0)
+    {
+      /* NB: When linking Windows x86-64 relocatable object files to
+	 generate ELF executable, create an indirect reference to
+	 __executable_start for __ImageBase to support R_AMD64_IMAGEBASE
+	 relocation which is relative to __ImageBase.  */
+      struct elf_link_hash_table *htab = elf_hash_table (&link_info);
+      struct elf_link_hash_entry *h, *hi;
+      hi = elf_link_hash_lookup (htab, "__ImageBase", TRUE, FALSE,
+				 FALSE);
+      if (hi->root.type == bfd_link_hash_new
+	  || hi->type == bfd_link_hash_undefined
+	  || hi->type == bfd_link_hash_undefweak)
+	{
+	  h = elf_link_hash_lookup (htab, "__executable_start",
+				    TRUE, FALSE, TRUE);
+	  hi->root.type = bfd_link_hash_indirect;
+	  hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
+	}
+    }
+
   /* Tell the ELF linker that we don't want the output file to have a
      DT_NEEDED entry for this file, unless it is used to resolve
      references in a regular object.  */
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-1.od b/ld/testsuite/ld-x86-64/pe-x86-64-1.od
index 4966d55fb5a..227875f82dc 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-1.od
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-1.od
@@ -2,6 +2,7 @@
 .*: +file format .*
 
 SYMBOL TABLE:
+0+400000 g       .text\$mn	0000000000000000 __executable_start
 0+401000 g       .text\$mn	0000000000000000 getaddr1
 0+401020 g       .text\$mn	0000000000000000 begin
 0+403014 g       .bss	0000000000000000 __bss_start
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-2.od b/ld/testsuite/ld-x86-64/pe-x86-64-2.od
index 4966d55fb5a..227875f82dc 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-2.od
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-2.od
@@ -2,6 +2,7 @@
 .*: +file format .*
 
 SYMBOL TABLE:
+0+400000 g       .text\$mn	0000000000000000 __executable_start
 0+401000 g       .text\$mn	0000000000000000 getaddr1
 0+401020 g       .text\$mn	0000000000000000 begin
 0+403014 g       .bss	0000000000000000 __bss_start
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-3.od b/ld/testsuite/ld-x86-64/pe-x86-64-3.od
index 4966d55fb5a..227875f82dc 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-3.od
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-3.od
@@ -2,6 +2,7 @@
 .*: +file format .*
 
 SYMBOL TABLE:
+0+400000 g       .text\$mn	0000000000000000 __executable_start
 0+401000 g       .text\$mn	0000000000000000 getaddr1
 0+401020 g       .text\$mn	0000000000000000 begin
 0+403014 g       .bss	0000000000000000 __bss_start
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-4.od b/ld/testsuite/ld-x86-64/pe-x86-64-4.od
index e0bde11d84e..320c6be5e14 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-4.od
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-4.od
@@ -2,6 +2,7 @@
 .*: +file format .*
 
 SYMBOL TABLE:
+0+400000 g       .text\$mn	0000000000000000 __executable_start
 0+403038 g       .bss	0000000000000000 c
 0+401000 g       .text\$mn	0000000000000000 begin
 0+403038 g       .bss	0000000000000000 __bss_start
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-5.od b/ld/testsuite/ld-x86-64/pe-x86-64-5.od
index 8a4f4a633ac..6ef13abbc94 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-5.od
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-5.od
@@ -4,6 +4,7 @@
 SYMBOL TABLE:
 0+402014 g       .bss	0000000000000000 non_initdummy
 0+402010 g       .data	0000000000000000 initdummy
+0+400000 g       .text\$mn	0000000000000000 __executable_start
 0+401000 g       .text\$mn	0000000000000000 begin
 0+402012 g       .bss	0000000000000000 __bss_start
 0+402000 g       .data	0000000000000000 Struct
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-5.rd b/ld/testsuite/ld-x86-64/pe-x86-64-5.rd
index 8370665f99f..237052805e9 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64-5.rd
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-5.rd
@@ -1,9 +1,10 @@
 
-Symbol table '.symtab' contains 10 entries:
+Symbol table '.symtab' contains 11 entries:
    Num:    Value          Size Type    Bind   Vis      Ndx Name
  +[a-f0-9]+: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
  +[a-f0-9]+: 0000000000402014     0 NOTYPE  GLOBAL DEFAULT    3 non_initdummy
  +[a-f0-9]+: 0000000000402010     0 NOTYPE  GLOBAL DEFAULT    2 initdummy
+ +[a-f0-9]+: 0000000000400000     0 NOTYPE  GLOBAL DEFAULT    1 __executable_start
  +[a-f0-9]+: 0000000000401000     0 NOTYPE  GLOBAL DEFAULT    1 begin
  +[a-f0-9]+: 0000000000402012     0 NOTYPE  GLOBAL DEFAULT    3 __bss_start
  +[a-f0-9]+: 0000000000402000     0 NOTYPE  GLOBAL DEFAULT    2 Struct
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-6.obj.bz2 b/ld/testsuite/ld-x86-64/pe-x86-64-6.obj.bz2
new file mode 100644
index 0000000000000000000000000000000000000000..38255045d45ed918857b2c966400c13a13ea6c07
GIT binary patch
literal 1366
zcmV-c1*!T%T4*^jL0KkKSr(o^9smO9fB*mf|Nh_a|NQ^||Nj5~-}TM^Q*@d9YgPW;
zd+eHR_F&KhxOk{DUEM>1DTr#B8Vxi9QxnNB$qe;OMn*LZjWonG!KBke34qcKG#-Lu
zO+n}oJfkP-n1+}m6BA7tp+8jd3aO!pXvlhuKmni)7)=4727@32A)%%dK*9h3GyobJ
zF#(`ypa1~S&<2Qtn+c+6qtZ`M(<VowN$4g48fl<tXa<3x8X7%78Z>F3218950002c
z8UPw-&;$&OhMHssLqH6JBSwQEplP9@hychk8Z-t#7$DFx0MG!_Kn#r-BS2^XN+L#+
zMDk%qX+0wvnd*n6$Y=o5O#sjXO#o;B000^Q000000BC8T01Y)6t0Ij%1~1Zx-ljTP
zv7~$gP4n@oNq~cfwyu(S%%**p^kz*r4rRAWRcTbfRNzb)2)m)XQMb&4JUVWwY*_%P
z_N_!via~?|2}vgnKR75Sr_AXg#*K-lYBJ6&yOYkj3SvkC7BnqXI+`VjgE9yrmM|#Z
zAcU!thFfPL@ogO(W&_wPR?O<Nl`>0!yz(SMNI$pgD>nP`qq5&di9Y(;<tzfve#7RV
zLQq7sR8<iKE~*d}9#I&mh}9UVJg8-r7@=xZ2NcmYhaEyPiYfpN6hw+h7>GbrM+HPo
z!i9>{yG<#;mMI1E_Jr`*O+8>~P!*e8kP;V5^pWooq=L*qp)SmVWvfu>f>_r&r(rc;
zFlw0LN0dbVEA<6bekiD-s;40s%X>e{Bpb{0V*cpCy@Z%%2(;IT0ltH`?_5}n<UzB5
zf*?Wx?9SUxvoz5xvF*HU!`az<4cefwMgW_uK?W~)_YEp5)<A$@1UQMSt7Vh|X$!8S
zrYkdd%PnrQQ=JI}l%S=Jf?!qja8)kH^@O)sYfeI3m645L`q5BGerN)K?of-0r#>n|
zIJ>G_Jer_3(hAJw3_-j#7s1%O?->CeCR~1-d~uAqlkd=kBse0+P!fP8Gf5HP-!7%i
zY9#t2m+xTN{>23e(7a+I0;{Zo0pKlR8D<0+3~@0q!8UtF@$=vS%Ru|zVD9FpjySx}
zt{H?(&9Uu<p2jzU;|+yP-xYy^SQTmsWFw3b42s1?DxF}&SjcKo)TM}4B<*K1;RKpr
zB9L9W4U0w48Omi$FhV&*nXBTNgK+&nY+(ea!;BBmP6EO12PwtkmC_%#RsA$z@0JaQ
zK;1$!^T@K75<Qv*kCpFrll-gW?LaFYfjkRsvaL~}G=vHfYrg~uZV?6S9IpF-0+5}A
z_)^1T9VRd5A4+zwe~%URaNDw|ovUUIblXiY&aNu_D<Fy>a;O36%A;_CC4P{I;g8Lc
z_oIb1Th5wd#<v-tRhnyBD_BF4(rrdPfGi+1Cj(c?t7>6DvSmSitld-B7DP!ulPV)v
zjtH{yhbV)vqPiypj+2XeCuKWhP+%%5BxPTeR&+A6ME(Spj<8A+AT>of%9IL${b3$W
zT;V{<37R=3O12yjn;D3J_1es%R~rCwc#07V>0~}6Ocbcd(xo^hbFZ_E5g`dK4J43;
zL!(RF%z~VRcxJ6*mWojmVMt69!e|;&A4@D>YChtn2o?5O0qUo}T)OBf@?k*9{q-V&
zj?~DI4x)@7n$%$cCX*@q$)0{8UXMIXT<xV^S2T@qb<#e0E#AcXnZlt{eAv$l(KnN1
zj%}2QO$7taoaiC>k}0dYOV~!Q%X-@vZSVa^tl(<I`&6AfE`zbF1)s_=HB>Bd6H=xt
Y$~B;AV5AHi$*u8sBvXY60cqp`;GR@oQ~&?~

literal 0
HcmV?d00001

diff --git a/ld/testsuite/ld-x86-64/pe-x86-64-6.od b/ld/testsuite/ld-x86-64/pe-x86-64-6.od
new file mode 100644
index 00000000000..cc23658a806
--- /dev/null
+++ b/ld/testsuite/ld-x86-64/pe-x86-64-6.od
@@ -0,0 +1,91 @@
+
+.*: +file format .*
+
+SYMBOL TABLE:
+0+4010a8 g       .text\$mn	0000000000000000 xfunc
+0+402000 g       .rdata	0000000000000000 \?\?_C@_02LDKJOMJN@AB@
+0+400000 g       .text\$mn	0000000000000000 __executable_start
+0+403058 g       .data	0000000000000000 __bss_start
+0+401000 g       .text\$mn	0000000000000000 main
+0+403038 g       .data	0000000000000000 deadloopvar
+0+4010ac g       .text\$mn	0000000000000000 xstring
+0+403058 g       .data	0000000000000000 _edata
+0+403058 g       .data	0000000000000000 _end
+
+
+
+Disassembly of section .text\$mn:
+
+0+401000 <main>:
+ +[a-f0-9]+:	48 89 5c 24 08       	mov    %rbx,0x8\(%rsp\)
+ +[a-f0-9]+:	48 89 6c 24 10       	mov    %rbp,0x10\(%rsp\)
+ +[a-f0-9]+:	48 89 74 24 20       	mov    %rsi,0x20\(%rsp\)
+ +[a-f0-9]+:	57                   	push   %rdi
+ +[a-f0-9]+:	48 83 ec 20          	sub    \$0x20,%rsp
+ +[a-f0-9]+:	cc                   	int3   
+ +[a-f0-9]+:	8b 05 1d 20 00 00    	mov    0x201d\(%rip\),%eax        # 403038 <deadloopvar>
+ +[a-f0-9]+:	83 f8 01             	cmp    \$0x1,%eax
+ +[a-f0-9]+:	74 f5                	je     401015 <main\+0x15>
+ +[a-f0-9]+:	0f 31                	rdtsc  
+ +[a-f0-9]+:	48 c1 e2 20          	shl    \$0x20,%rdx
+ +[a-f0-9]+:	48 0b c2             	or     %rdx,%rax
+ +[a-f0-9]+:	74 5d                	je     401088 <main\+0x88>
+ +[a-f0-9]+:	33 ff                	xor    %edi,%edi
+ +[a-f0-9]+:	48 8d 2d cc ef ff ff 	lea    -0x1034\(%rip\),%rbp        # 400000 <__executable_start>
+ +[a-f0-9]+:	33 db                	xor    %ebx,%ebx
+ +[a-f0-9]+:	48 8d 35 ff 1f 00 00 	lea    0x1fff\(%rip\),%rsi        # 40303c <deadloopvar\+0x4>
+ +[a-f0-9]+:	48 8b 8c 2b 50 30 00 00 	mov    0x3050\(%rbx,%rbp,1\),%rcx
+ +[a-f0-9]+:	44 8a 01             	mov    \(%rcx\),%r8b
+ +[a-f0-9]+:	45 84 c0             	test   %r8b,%r8b
+ +[a-f0-9]+:	74 28                	je     401075 <main\+0x75>
+ +[a-f0-9]+:	b8 05 00 00 00       	mov    \$0x5,%eax
+ +[a-f0-9]+:	2b 84 2b 48 30 00 00 	sub    0x3048\(%rbx,%rbp,1\),%eax
+ +[a-f0-9]+:	99                   	cltd   
+ +[a-f0-9]+:	2b c2                	sub    %edx,%eax
+ +[a-f0-9]+:	d1 f8                	sar    %eax
+ +[a-f0-9]+:	48 63 d0             	movslq %eax,%rdx
+ +[a-f0-9]+:	48 03 d6             	add    %rsi,%rdx
+ +[a-f0-9]+:	48 ff c1             	inc    %rcx
+ +[a-f0-9]+:	44 88 02             	mov    %r8b,\(%rdx\)
+ +[a-f0-9]+:	48 ff c2             	inc    %rdx
+ +[a-f0-9]+:	44 8a 01             	mov    \(%rcx\),%r8b
+ +[a-f0-9]+:	45 84 c0             	test   %r8b,%r8b
+ +[a-f0-9]+:	75 ef                	jne    401064 <main\+0x64>
+ +[a-f0-9]+:	48 8b ce             	mov    %rsi,%rcx
+ +[a-f0-9]+:	e8 2f 00 00 00       	call   4010ac <xstring>
+ +[a-f0-9]+:	ff c7                	inc    %edi
+ +[a-f0-9]+:	48 83 c3 08          	add    \$0x8,%rbx
+ +[a-f0-9]+:	83 ff 01             	cmp    \$0x1,%edi
+ +[a-f0-9]+:	72 b5                	jb     40103d <main\+0x3d>
+ +[a-f0-9]+:	b1 aa                	mov    \$0xaa,%cl
+ +[a-f0-9]+:	e8 19 00 00 00       	call   4010a8 <xfunc>
+ +[a-f0-9]+:	48 8b 5c 24 30       	mov    0x30\(%rsp\),%rbx
+ +[a-f0-9]+:	33 c0                	xor    %eax,%eax
+ +[a-f0-9]+:	48 8b 6c 24 38       	mov    0x38\(%rsp\),%rbp
+ +[a-f0-9]+:	48 8b 74 24 48       	mov    0x48\(%rsp\),%rsi
+ +[a-f0-9]+:	48 83 c4 20          	add    \$0x20,%rsp
+ +[a-f0-9]+:	5f                   	pop    %rdi
+ +[a-f0-9]+:	c3                   	ret    
+ +[a-f0-9]+:	66 90                	xchg   %ax,%ax
+
+0+4010a8 <xfunc>:
+ +[a-f0-9]+:	66 90                	xchg   %ax,%ax
+ +[a-f0-9]+:	cc                   	int3   
+ +[a-f0-9]+:	c3                   	ret    
+
+0+4010ac <xstring>:
+ +[a-f0-9]+:	40 53                	rex push %rbx
+ +[a-f0-9]+:	48 83 ec 20          	sub    \$0x20,%rsp
+ +[a-f0-9]+:	8a 01                	mov    \(%rcx\),%al
+ +[a-f0-9]+:	48 8b d9             	mov    %rcx,%rbx
+ +[a-f0-9]+:	eb 0c                	jmp    4010c5 <xstring\+0x19>
+ +[a-f0-9]+:	8a c8                	mov    %al,%cl
+ +[a-f0-9]+:	e8 e8 ff ff ff       	call   4010a8 <xfunc>
+ +[a-f0-9]+:	48 ff c3             	inc    %rbx
+ +[a-f0-9]+:	8a 03                	mov    \(%rbx\),%al
+ +[a-f0-9]+:	84 c0                	test   %al,%al
+ +[a-f0-9]+:	75 f0                	jne    4010b9 <xstring\+0xd>
+ +[a-f0-9]+:	48 83 c4 20          	add    \$0x20,%rsp
+ +[a-f0-9]+:	5b                   	pop    %rbx
+ +[a-f0-9]+:	c3                   	ret    
+#pass
diff --git a/ld/testsuite/ld-x86-64/pe-x86-64.exp b/ld/testsuite/ld-x86-64/pe-x86-64.exp
index ccfcdfaddfb..f5d2c84f283 100644
--- a/ld/testsuite/ld-x86-64/pe-x86-64.exp
+++ b/ld/testsuite/ld-x86-64/pe-x86-64.exp
@@ -73,4 +73,13 @@ run_ld_link_tests [list \
 	 {readelf {-s -x .data} pe-x86-64-5.rd}} \
 	"pe-x86-64-5" \
     ] \
+    [list \
+	"Build pe-x86-64-6" \
+	"-m elf_x86_64 --entry=main" \
+	"" \
+	"" \
+	{pe-x86-64-6.obj.bz2 } \
+	{{objdump {-dw --sym} pe-x86-64-6.od}} \
+	"pe-x86-64-6" \
+    ] \
 ]
-- 
2.29.2