[OpenRISC] [PATCH v2 0/4] OpenRISC large binary fixes

[OpenRISC] [PATCH v2 0/4] OpenRISC large binary fixes

[Stafford Horne]

Changes since v1:
 - Replaced patches 3/4 with a different approach.  Instead of relying on seeing
   R_OR1K_GOT_AHI16 relocations to enable large plts, I just track the PLT entry
   count and switch to large PLT when we detect the overflow will occur.
 - Patch "Avoid R_OR1K_GOT16 overflow failures in presence of R_OR1K_GOT_AHI16"
   is the actual bug fix for 21464, which was missed in the original series.  We
   inhibit truncation detection when the low got() relocation is paired with the
   new high gotha() relocation.

These are several fixes to OpenRISC BFD to handle issues mostly related to
linking large files.

There will be a GCC patch then depends on this, a new -mcmodel=large argument is
added to GCC to allow creating GOT relocation values larger than 64k.

The series fixes 3 issues:

 * PR 27624 - Assertion failure when dynamic symol is localized
 * PR 21464 - GOT relocation truncation.
 * PR 27746 - Issue with silent overlows in PLT code.

Stafford Horne (4):
  or1k: Fix issue with plt link failure for local calls
  or1k: Implement relocation R_OR1K_GOT_AHI16 for gotha()
  or1k: Avoid R_OR1K_GOT16 overflow failures in presence of
    R_OR1K_GOT_AHI16
  or1k: Support large plt_relocs when generating plt entries

 bfd/bfd-in2.h                    |   1 +
 bfd/elf32-or1k.c                 | 190 +++++++++++++++++++++++--------
 bfd/libbfd.h                     |   1 +
 bfd/reloc.c                      |   2 +
 cpu/or1k.opc                     |   7 +-
 gas/testsuite/gas/or1k/reloc-1.d |   4 +-
 gas/testsuite/gas/or1k/reloc-1.s |   4 +
 include/elf/or1k.h               |   1 +
 ld/testsuite/ld-or1k/gotha1.dd   |  34 ++++++
 ld/testsuite/ld-or1k/gotha1.s    |  24 ++++
 ld/testsuite/ld-or1k/gotha2.dd   |  21 ++++
 ld/testsuite/ld-or1k/gotha2.s    |  22 ++++
 ld/testsuite/ld-or1k/or1k.exp    |   8 ++
 ld/testsuite/ld-or1k/pltlib.s    |   1 +
 opcodes/or1k-asm.c               |   7 +-
 15 files changed, 279 insertions(+), 48 deletions(-)
 create mode 100644 ld/testsuite/ld-or1k/gotha1.dd
 create mode 100644 ld/testsuite/ld-or1k/gotha1.s
 create mode 100644 ld/testsuite/ld-or1k/gotha2.dd
 create mode 100644 ld/testsuite/ld-or1k/gotha2.s

-- 
2.26.2

[OpenRISC] [PATCH v2 1/4] or1k: Fix issue with plt link failure for local calls

[Stafford Horne]

When building protobuf we were seeing the assert failure:

    /home/giuliobenetti/git/upstream/or1k-binutils-2.36.1/host/lib/gcc/or1k-buildroot-linux-uclibc/9.3.0/../../../../or1k-buildroot-linux-uclibc/bin/ld:
    BFD (GNU Binutils) 2.36.1 assertion fail elf32-or1k.c:2377
    /home/giuliobenetti/git/upstream/or1k-binutils-2.36.1/host/lib/gcc/or1k-buildroot-linux-uclibc/9.3.0/../../../../or1k-buildroot-linux-uclibc/bin/ld:
    BFD (GNU Binutils) 2.36.1 assertion fail elf32-or1k.c:2377
    /home/giuliobenetti/git/upstream/or1k-binutils-2.36.1/host/lib/gcc/or1k-buildroot-linux-uclibc/9.3.0/../../../../or1k-buildroot-linux-uclibc/bin/ld:
    BFD (GNU Binutils) 2.36.1 assertion fail elf32-or1k.c:2377
    collect2: error: ld returned 1 exit status

This failure happens while writing out PLT entries, there is a check
"BFD_ASSERT (h->dynindx != -1)" to confirm all plt entries have dynamic
symbol attributes.  This was failing for symbols that were
"forced_local" in previous linking code.

The fix adds logic to or1k_elf_adjust_dynamic_symbol to identify
"forced_local" symbols and exclude them from the the PLT.

bfd/ChangeLog:

	PR 27624
	* elf32-or1k.c (or1k_elf_adjust_dynamic_symbol): Change
	condition used to cleanup plt entries to cleanup forced local
	entries.

Cc: Giulio Benetti <giulio.benetti@benettiengineering.com>
---
 bfd/elf32-or1k.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/bfd/elf32-or1k.c b/bfd/elf32-or1k.c
index 013deb406f8..cc6c51220e5 100644
--- a/bfd/elf32-or1k.c
+++ b/bfd/elf32-or1k.c
@@ -2566,11 +2566,10 @@ or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
   if (h->type == STT_FUNC
       || h->needs_plt)
     {
-      if (! bfd_link_pic (info)
-	  && !h->def_dynamic
-	  && !h->ref_dynamic
-	  && h->root.type != bfd_link_hash_undefweak
-	  && h->root.type != bfd_link_hash_undefined)
+      if (h->plt.refcount <= 0
+	  || (SYMBOL_CALLS_LOCAL (info, h)
+	  || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
+	      && h->root.type == bfd_link_hash_undefweak)))
 	{
 	  /* This case can occur if we saw a PLT reloc in an input
 	     file, but the symbol was never referred to by a dynamic
-- 
2.26.2

[OpenRISC] [PATCH v2 2/4] or1k: Implement relocation R_OR1K_GOT_AHI16 for gotha()

[Stafford Horne]

The gotha() relocation mnemonic will be outputted by OpenRISC GCC when
using the -mcmodel=large option.  This relocation is used along with
got() to generate 32-bit GOT offsets.  This increases the previous GOT
offset limit from the previous 16-bit (64K) limit.

This is needed on large binaries where the GOT grows larger than 64k.

bfd/ChangeLog:

	PR 21464
	* bfd-in2.h: Add BFD_RELOC_OR1K_GOT_AHI16 relocation.
	* elf32-or1k.c (or1k_elf_howto_table, or1k_reloc_map): Likewise.
	(or1k_final_link_relocate, or1k_elf_relocate_section,
	or1k_elf_check_relocs): Likewise.
	* libbfd.h (bfd_reloc_code_real_names): Likewise.
	* reloc.c: Likewise.

cpu/ChangeLog:

	PR 21464
	* or1k.opc (or1k_imm16_relocs, parse_reloc): Define parse logic
	for gotha() relocation.

include/ChangeLog:

	PR 21464
	* elf/or1k.h (elf_or1k_reloc_type): Define R_OR1K_GOT_AHI16 number.

opcodes/ChangeLog:

	PR 21464
	* or1k-asm.c: Regenerate.

gas/ChangeLog:

	PR 21464
	* testsuite/gas/or1k/reloc-1.s: Add test for new relocation.
	* testsuite/gas/or1k/reloc-1.d: Add test result for new
	relocation.

Cc: Giulio Benetti <giulio.benetti@benettiengineering.com>

fixup reloc, add tests
---
 bfd/bfd-in2.h                    |  1 +
 bfd/elf32-or1k.c                 | 21 ++++++++++++++++++++-
 bfd/libbfd.h                     |  1 +
 bfd/reloc.c                      |  2 ++
 cpu/or1k.opc                     |  7 ++++++-
 gas/testsuite/gas/or1k/reloc-1.d |  4 +++-
 gas/testsuite/gas/or1k/reloc-1.s |  4 ++++
 include/elf/or1k.h               |  1 +
 opcodes/or1k-asm.c               |  7 ++++++-
 9 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index cdfb933e30d..ca1b3a537de 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -5031,6 +5031,7 @@ then it may be truncated to 8 bits.  */
   BFD_RELOC_OR1K_TLS_TPOFF,
   BFD_RELOC_OR1K_TLS_DTPOFF,
   BFD_RELOC_OR1K_TLS_DTPMOD,
+  BFD_RELOC_OR1K_GOT_AHI16,
 
 /* H8 elf Relocations.  */
   BFD_RELOC_H8_DIR16A8,
diff --git a/bfd/elf32-or1k.c b/bfd/elf32-or1k.c
index cc6c51220e5..1b8938df37f 100644
--- a/bfd/elf32-or1k.c
+++ b/bfd/elf32-or1k.c
@@ -808,6 +808,20 @@ static reloc_howto_type or1k_elf_howto_table[] =
 	 0,			/* Source Mask.  */
 	 0x03ffffff,		/* Dest Mask.  */
 	 true),			/* PC relative offset?  */
+
+  HOWTO (R_OR1K_GOT_AHI16,	/* type */
+	 16,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 bfd_elf_generic_reloc, /* special_function */
+	 "R_OR1K_GOT_AHI16",	/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
 };
 
 /* Map BFD reloc types to Or1k ELF reloc types.  */
@@ -871,6 +885,7 @@ static const struct or1k_reloc_map or1k_reloc_map[] =
   { BFD_RELOC_OR1K_TLS_IE_LO13,	R_OR1K_TLS_IE_LO13 },
   { BFD_RELOC_OR1K_SLO13,	R_OR1K_SLO13 },
   { BFD_RELOC_OR1K_PLTA26,	R_OR1K_PLTA26 },
+  { BFD_RELOC_OR1K_GOT_AHI16,	R_OR1K_GOT_AHI16 },
 };
 
 /* tls_type is a mask used to track how each symbol is accessed,
@@ -1111,6 +1126,7 @@ or1k_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
   switch (howto->type)
     {
     case R_OR1K_AHI16:
+    case R_OR1K_GOT_AHI16:
     case R_OR1K_GOTOFF_AHI16:
     case R_OR1K_TLS_IE_AHI16:
     case R_OR1K_TLS_LE_AHI16:
@@ -1373,6 +1389,7 @@ or1k_elf_relocate_section (bfd *output_bfd,
 	    }
 	  break;
 
+	case R_OR1K_GOT_AHI16:
 	case R_OR1K_GOT16:
 	case R_OR1K_GOT_PG21:
 	case R_OR1K_GOT_LO13:
@@ -1464,7 +1481,8 @@ or1k_elf_relocate_section (bfd *output_bfd,
 	    /* The GOT_PG21 and GOT_LO13 relocs are pc-relative,
 	       while the GOT16 reloc is GOT relative.  */
 	    relocation = got_base + off;
-	    if (r_type == R_OR1K_GOT16)
+	    if (r_type == R_OR1K_GOT16
+		|| r_type == R_OR1K_GOT_AHI16)
 	      relocation -= got_sym_value;
 
 	  /* Addend should be zero.  */
@@ -1990,6 +2008,7 @@ or1k_elf_check_relocs (bfd *abfd,
 	    }
 	  break;
 
+	case R_OR1K_GOT_AHI16:
 	case R_OR1K_GOT16:
 	case R_OR1K_GOT_PG21:
 	case R_OR1K_GOT_LO13:
diff --git a/bfd/libbfd.h b/bfd/libbfd.h
index f1d25d0ab1f..793437ef260 100644
--- a/bfd/libbfd.h
+++ b/bfd/libbfd.h
@@ -2771,6 +2771,7 @@ static const char *const bfd_reloc_code_real_names[] = { "@@uninitialized@@",
   "BFD_RELOC_OR1K_TLS_TPOFF",
   "BFD_RELOC_OR1K_TLS_DTPOFF",
   "BFD_RELOC_OR1K_TLS_DTPMOD",
+  "BFD_RELOC_OR1K_GOT_AHI16",
   "BFD_RELOC_H8_DIR16A8",
   "BFD_RELOC_H8_DIR16R8",
   "BFD_RELOC_H8_DIR24A8",
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 2eb0758a82c..896c1723f8d 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -6204,6 +6204,8 @@ ENUMX
   BFD_RELOC_OR1K_GOTPC_HI16
 ENUMX
   BFD_RELOC_OR1K_GOTPC_LO16
+ENUMX
+  BFD_RELOC_OR1K_GOT_AHI16
 ENUMX
   BFD_RELOC_OR1K_GOT16
 ENUMX
diff --git a/cpu/or1k.opc b/cpu/or1k.opc
index f0adcbb00a5..5d20a1f33a7 100644
--- a/cpu/or1k.opc
+++ b/cpu/or1k.opc
@@ -193,7 +193,7 @@ static const bfd_reloc_code_real_type or1k_imm16_relocs[][6] = {
     BFD_RELOC_OR1K_GOT_LO13,
     BFD_RELOC_UNUSED,
     BFD_RELOC_UNUSED,
-    BFD_RELOC_UNUSED },
+    BFD_RELOC_OR1K_GOT_AHI16 },
   { BFD_RELOC_OR1K_GOTPC_LO16,
     BFD_RELOC_UNUSED,
     BFD_RELOC_UNUSED,
@@ -296,6 +296,11 @@ parse_reloc (const char **strp)
 	str += 5;
 	cls = RCLASS_TPOFF;
       }
+    else if (strncasecmp (str, "got", 3) == 0)
+      {
+	str += 3;
+	cls = RCLASS_GOT;
+      }
 
     if (strncasecmp (str, "hi(", 3) == 0)
       {
diff --git a/gas/testsuite/gas/or1k/reloc-1.d b/gas/testsuite/gas/or1k/reloc-1.d
index d1bcf5608bb..3a001c4ed99 100644
--- a/gas/testsuite/gas/or1k/reloc-1.d
+++ b/gas/testsuite/gas/or1k/reloc-1.d
@@ -68,5 +68,7 @@ OFFSET   TYPE              VALUE
 000000ec R_OR1K_LO13       x
 000000f0 R_OR1K_GOT_LO13   x
 000000f4 R_OR1K_SLO13      x
-
+000000f8 R_OR1K_GOT_AHI16  x
+000000fc R_OR1K_GOT_AHI16  x
+00000100 R_OR1K_GOT_AHI16  x
 
diff --git a/gas/testsuite/gas/or1k/reloc-1.s b/gas/testsuite/gas/or1k/reloc-1.s
index e76abef6532..562609aa869 100644
--- a/gas/testsuite/gas/or1k/reloc-1.s
+++ b/gas/testsuite/gas/or1k/reloc-1.s
@@ -74,3 +74,7 @@
 	l.lbz	r5,po(x)(r3)
 	l.lbz	r5,gotpo(x)(r3)
 	l.sb	po(x)(r3),r6
+
+	l.movhi	r4,gotha(x)
+	l.ori	r3,r4,gotha(x)
+	l.addi	r3,r4,gotha(x)
diff --git a/include/elf/or1k.h b/include/elf/or1k.h
index 7f281481061..69ab90584a2 100644
--- a/include/elf/or1k.h
+++ b/include/elf/or1k.h
@@ -77,6 +77,7 @@ START_RELOC_NUMBERS (elf_or1k_reloc_type)
   RELOC_NUMBER (R_OR1K_TLS_IE_LO13,   51)
   RELOC_NUMBER (R_OR1K_SLO13,         52)
   RELOC_NUMBER (R_OR1K_PLTA26,        53)
+  RELOC_NUMBER (R_OR1K_GOT_AHI16,     54)
 END_RELOC_NUMBERS (R_OR1K_max)
 
 #define EF_OR1K_NODELAY (1UL << 0)
diff --git a/opcodes/or1k-asm.c b/opcodes/or1k-asm.c
index 045ab6230b6..fdccf67f9e1 100644
--- a/opcodes/or1k-asm.c
+++ b/opcodes/or1k-asm.c
@@ -177,7 +177,7 @@ static const bfd_reloc_code_real_type or1k_imm16_relocs[][6] = {
     BFD_RELOC_OR1K_GOT_LO13,
     BFD_RELOC_UNUSED,
     BFD_RELOC_UNUSED,
-    BFD_RELOC_UNUSED },
+    BFD_RELOC_OR1K_GOT_AHI16 },
   { BFD_RELOC_OR1K_GOTPC_LO16,
     BFD_RELOC_UNUSED,
     BFD_RELOC_UNUSED,
@@ -280,6 +280,11 @@ parse_reloc (const char **strp)
 	str += 5;
 	cls = RCLASS_TPOFF;
       }
+    else if (strncasecmp (str, "got", 3) == 0)
+      {
+	str += 3;
+	cls = RCLASS_GOT;
+      }
 
     if (strncasecmp (str, "hi(", 3) == 0)
       {
-- 
2.26.2

[OpenRISC] [PATCH v2 3/4] or1k: Avoid R_OR1K_GOT16 overflow failures in presence of R_OR1K_GOT_AHI16

[Stafford Horne]

Now that we support R_OR1K_GOT_AHI16 we can relax the R_OR1K_GOT16
overflow validation check if the section has R_OR1K_GOT_AHI16.

We cannot simple disable R_OR1K_GOT16 overflow validation as there will
still be binaries that will have only R_OR1K_GOT16.  The
R_OR1K_GOT_AHI16 relocation will only be added by GCC when building with
the option -mcmodel=large.

This assumes that R_OR1K_GOT_AHI16 will come before R_OR1K_GOT16, which
is the code pattern that will be emitted by GCC.

bfd/ChangeLog:

	PR 21464
	* elf32-or1k.c (or1k_elf_relocate_section): Relax R_OR1K_GOT16
	overflow check if we have R_OR1K_GOT_AHI16 followed by
	R_OR1K_GOT16.
---
 bfd/elf32-or1k.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/bfd/elf32-or1k.c b/bfd/elf32-or1k.c
index 1b8938df37f..5eca4300c45 100644
--- a/bfd/elf32-or1k.c
+++ b/bfd/elf32-or1k.c
@@ -1278,6 +1278,7 @@ or1k_elf_relocate_section (bfd *output_bfd,
   asection *sgot, *splt;
   bfd_vma plt_base, got_base, got_sym_value;
   bool ret_val = true;
+  bool saw_gotha = false;
 
   if (htab == NULL)
     return false;
@@ -1485,6 +1486,16 @@ or1k_elf_relocate_section (bfd *output_bfd,
 		|| r_type == R_OR1K_GOT_AHI16)
 	      relocation -= got_sym_value;
 
+	    if (r_type == R_OR1K_GOT_AHI16)
+	      saw_gotha = true;
+
+	    /* If we have a R_OR1K_GOT16 followed by a R_OR1K_GOT_AHI16
+	       relocation we assume the code is doing the right thing to avoid
+	       overflows.  Here we mask the lower 16-bit of the relocation to
+	       avoid overflow validation failures.  */
+	    if (r_type == R_OR1K_GOT16 && saw_gotha)
+	      relocation &= 0xffff;
+
 	  /* Addend should be zero.  */
 	  if (rel->r_addend != 0)
 	    {
-- 
2.26.2

[OpenRISC] [PATCH v2 4/4] or1k: Support large plt_relocs when generating plt entries

[Stafford Horne]

The current PLT generation code will generate invalid code when the PLT
relocation offset exceeds 64k.  This fixes the issue by detecting large
plt_reloc offsets and generare code sequences to create larger plt
relocations.

The "large" plt code needs 2 extra instructions to create 32-bit offsets.

bfd/ChangeLog:

	PR 27746
	* elf32-or1k.c (PLT_ENTRY_SIZE_LARGE, PLT_MAX_INSN_COUNT,
	OR1K_ADD, OR1K_ORI): New macros to help with plt creation.
	(elf_or1k_link_hash_table): New field plt_count.
	(elf_or1k_link_hash_entry): New field plt_index.
	(elf_or1k_plt_entry_size): New function.
	(or1k_write_plt_entry): Update to support variable size PLTs.
	(or1k_elf_finish_dynamic_sections): Use new or1k_write_plt_entry
	API.
	(or1k_elf_finish_dynamic_symbol): Update to write large PLTs
	when needed.
	(allocate_dynrelocs): Use elf_or1k_plt_entry_size to account for
	PLT size.

ld/ChangeLog:

	PR 27746
	testsuite/ld-or1k/or1k.exp (or1kplttests): Add tests for linking
	along with gotha() relocations.
	testsuite/ld-or1k/gotha1.dd: New file.
	testsuite/ld-or1k/gotha1.s: New file.
	testsuite/ld-or1k/gotha2.dd: New file.
	testsuite/ld-or1k/gotha2.s: New file
	testsuite/ld-or1k/pltlib.s (x): Define size to avoid link
	failure.
---
 bfd/elf32-or1k.c               | 149 ++++++++++++++++++++++++---------
 ld/testsuite/ld-or1k/gotha1.dd |  34 ++++++++
 ld/testsuite/ld-or1k/gotha1.s  |  24 ++++++
 ld/testsuite/ld-or1k/gotha2.dd |  21 +++++
 ld/testsuite/ld-or1k/gotha2.s  |  22 +++++
 ld/testsuite/ld-or1k/or1k.exp  |   8 ++
 ld/testsuite/ld-or1k/pltlib.s  |   1 +
 7 files changed, 220 insertions(+), 39 deletions(-)
 create mode 100644 ld/testsuite/ld-or1k/gotha1.dd
 create mode 100644 ld/testsuite/ld-or1k/gotha1.s
 create mode 100644 ld/testsuite/ld-or1k/gotha2.dd
 create mode 100644 ld/testsuite/ld-or1k/gotha2.s

diff --git a/bfd/elf32-or1k.c b/bfd/elf32-or1k.c
index 5eca4300c45..4ae7f324d33 100644
--- a/bfd/elf32-or1k.c
+++ b/bfd/elf32-or1k.c
@@ -30,10 +30,14 @@
 #define N_ONES(X)	(((bfd_vma)2 << (X)) - 1)
 
 #define PLT_ENTRY_SIZE 16
+#define PLT_ENTRY_SIZE_LARGE (6*4)
+#define PLT_MAX_INSN_COUNT 6
 
 #define OR1K_MOVHI(D)		(0x18000000 | (D << 21))
 #define OR1K_ADRP(D)		(0x08000000 | (D << 21))
 #define OR1K_LWZ(D,A)		(0x84000000 | (D << 21) | (A << 16))
+#define OR1K_ADD(D,A,B)		(0xE0000000 | (D << 21) | (A << 16) | (B << 11))
+#define OR1K_ORI(D,A)		(0xA8000000 | (D << 21) | (A << 16))
 #define OR1K_ORI0(D)		(0xA8000000 | (D << 21))
 #define OR1K_JR(B)		(0x44000000 | (B << 11))
 #define OR1K_NOP		0x15000000
@@ -907,6 +911,8 @@ struct elf_or1k_link_hash_entry
 {
   struct elf_link_hash_entry root;
 
+  /* For calculating PLT size.  */
+  bfd_vma plt_index;
   /* Track type of TLS access.  */
   unsigned char tls_type;
 };
@@ -931,9 +937,20 @@ struct elf_or1k_link_hash_table
 {
   struct elf_link_hash_table root;
 
+  bfd_vma plt_count;
   bool saw_plta;
 };
 
+static size_t
+elf_or1k_plt_entry_size (bfd_vma plt_index)
+{
+  bfd_vma plt_reloc;
+
+  plt_reloc = plt_index * sizeof (Elf32_External_Rela);
+
+  return (plt_reloc > 0xffff) ? PLT_ENTRY_SIZE_LARGE : PLT_ENTRY_SIZE;
+}
+
 /* Get the ELF linker hash table from a link_info structure.  */
 #define or1k_elf_hash_table(p) \
   ((is_elf_hash_table ((p)->hash)					\
@@ -2222,33 +2239,46 @@ or1k_elf_check_relocs (bfd *abfd,
 }
 
 static void
-or1k_write_plt_entry (bfd *output_bfd, bfd_byte *contents, unsigned insn1,
-		      unsigned insn2, unsigned insn3, unsigned insnj)
+or1k_write_plt_entry (bfd *output_bfd, bfd_byte *contents, unsigned insnj,
+		      unsigned insns[], size_t insn_count)
 {
   unsigned nodelay = elf_elfheader (output_bfd)->e_flags & EF_OR1K_NODELAY;
-  unsigned insn4;
+  unsigned output_insns[PLT_MAX_INSN_COUNT];
+
+  /* Copy instructions into the output buffer.  */
+  for (size_t i = 0; i < insn_count; i++)
+    output_insns[i] = insns[i];
 
   /* Honor the no-delay-slot setting.  */
-  if (insn3 == OR1K_NOP)
+  if (insns[insn_count-1] == OR1K_NOP)
     {
-      insn4 = insn3;
+      unsigned slot1, slot2;
+
       if (nodelay)
-	insn3 = insnj;
+	slot1 = insns[insn_count-2], slot2 = insnj;
       else
-	insn3 = insn2, insn2 = insnj;
+	slot1 = insnj, slot2 = insns[insn_count-2];
+
+      output_insns[insn_count-2] = slot1;
+      output_insns[insn_count-1] = slot2;
+      output_insns[insn_count]   = OR1K_NOP;
     }
   else
     {
+      unsigned slot1, slot2;
+
       if (nodelay)
-	insn4 = insnj;
+	slot1 = insns[insn_count-1], slot2 = insnj;
       else
-	insn4 = insn3, insn3 = insnj;
+	slot1 = insnj, slot2 = insns[insn_count-1];
+
+      output_insns[insn_count-1] = slot1;
+      output_insns[insn_count]   = slot2;
     }
 
-  bfd_put_32 (output_bfd, insn1, contents);
-  bfd_put_32 (output_bfd, insn2, contents + 4);
-  bfd_put_32 (output_bfd, insn3, contents + 8);
-  bfd_put_32 (output_bfd, insn4, contents + 12);
+  /* Write out the output buffer.  */
+  for (size_t i = 0; i < (insn_count+1); i++)
+    bfd_put_32 (output_bfd, output_insns[i], contents + (i*4));
 }
 
 /* Finish up the dynamic sections.  */
@@ -2315,7 +2345,8 @@ or1k_elf_finish_dynamic_sections (bfd *output_bfd,
       splt = htab->root.splt;
       if (splt && splt->size > 0)
 	{
-	  unsigned plt0, plt1, plt2;
+	  unsigned plt[PLT_MAX_INSN_COUNT];
+	  size_t plt_insn_count = 3;
 	  bfd_vma got_addr = sgot->output_section->vma + sgot->output_offset;
 
 	  /* Note we force 16 byte alignment on the .got, so that
@@ -2326,27 +2357,27 @@ or1k_elf_finish_dynamic_sections (bfd *output_bfd,
 	      bfd_vma pc = splt->output_section->vma + splt->output_offset;
 	      unsigned pa = ((got_addr >> 13) - (pc >> 13)) & 0x1fffff;
 	      unsigned po = got_addr & 0x1fff;
-	      plt0 = OR1K_ADRP(12) | pa;
-	      plt1 = OR1K_LWZ(15,12) | (po + 8);
-	      plt2 = OR1K_LWZ(12,12) | (po + 4);
+	      plt[0] = OR1K_ADRP(12) | pa;
+	      plt[1] = OR1K_LWZ(15,12) | (po + 8);
+	      plt[2] = OR1K_LWZ(12,12) | (po + 4);
 	    }
 	  else if (bfd_link_pic (info))
 	    {
-	      plt0 = OR1K_LWZ(15, 16) | 8;	/* .got+8 */
-	      plt1 = OR1K_LWZ(12, 16) | 4;	/* .got+4 */
-	      plt2 = OR1K_NOP;
+	      plt[0] = OR1K_LWZ(15, 16) | 8;	/* .got+8 */
+	      plt[1] = OR1K_LWZ(12, 16) | 4;	/* .got+4 */
+	      plt[2] = OR1K_NOP;
 	    }
 	  else
 	    {
 	      unsigned ha = ((got_addr + 0x8000) >> 16) & 0xffff;
 	      unsigned lo = got_addr & 0xffff;
-	      plt0 = OR1K_MOVHI(12) | ha;
-	      plt1 = OR1K_LWZ(15,12) | (lo + 8);
-	      plt2 = OR1K_LWZ(12,12) | (lo + 4);
+	      plt[0] = OR1K_MOVHI(12) | ha;
+	      plt[1] = OR1K_LWZ(15,12) | (lo + 8);
+	      plt[2] = OR1K_LWZ(12,12) | (lo + 4);
 	    }
 
-	  or1k_write_plt_entry (output_bfd, splt->contents,
-				plt0, plt1, plt2, OR1K_JR(15));
+	  or1k_write_plt_entry (output_bfd, splt->contents, OR1K_JR(15),
+				plt, plt_insn_count);
 
 	  elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
 	}
@@ -2389,7 +2420,8 @@ or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
 
   if (h->plt.offset != (bfd_vma) -1)
     {
-      unsigned int plt0, plt1, plt2;
+      unsigned int plt[PLT_MAX_INSN_COUNT];
+      size_t plt_insn_count = 3;
       asection *splt;
       asection *sgot;
       asection *srela;
@@ -2401,6 +2433,7 @@ or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
       bfd_vma got_offset;
       bfd_vma got_addr;
       Elf_Internal_Rela rela;
+      bool large_plt_entry;
 
       /* This symbol has an entry in the procedure linkage table.  Set
 	 it up.  */
@@ -2418,10 +2451,13 @@ or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
 	 corresponds to this symbol.  This is the index of this symbol
 	 in all the symbols for which we are making plt entries.  The
 	 first entry in the procedure linkage table is reserved.  */
-      plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
+      plt_index = ((struct elf_or1k_link_hash_entry *) h)->plt_index;
       plt_addr = plt_base_addr + h->plt.offset;
       plt_reloc = plt_index * sizeof (Elf32_External_Rela);
 
+      large_plt_entry = (elf_or1k_plt_entry_size (plt_index)
+			 == PLT_ENTRY_SIZE_LARGE);
+
       /* Get the offset into the .got table of the entry that
 	corresponds to this function.  Each .got entry is 4 bytes.
 	The first three are reserved.  */
@@ -2433,27 +2469,57 @@ or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
 	{
 	  unsigned pa = ((got_addr >> 13) - (plt_addr >> 13)) & 0x1fffff;
 	  unsigned po = (got_addr & 0x1fff);
-	  plt0 = OR1K_ADRP(12) | pa;
-	  plt1 = OR1K_LWZ(12,12) | po;
-	  plt2 = OR1K_ORI0(11) | plt_reloc;
+	  plt[0] = OR1K_ADRP(12) | pa;
+	  plt[1] = OR1K_LWZ(12,12) | po;
+	  plt[2] = OR1K_ORI0(11) | plt_reloc;
 	}
       else if (bfd_link_pic (info))
 	{
-	  plt0 = OR1K_LWZ(12,16) | got_offset;
-	  plt1 = OR1K_ORI0(11) | plt_reloc;
-	  plt2 = OR1K_NOP;
+	  if (large_plt_entry)
+	    {
+	      unsigned gotha = ((got_offset + 0x8000) >> 16) & 0xffff;
+	      unsigned got = got_offset & 0xffff;
+	      unsigned pltrelhi = (plt_reloc >> 16) & 0xffff;
+	      unsigned pltrello = plt_reloc & 0xffff;
+
+	      plt[0] = OR1K_MOVHI(12) | gotha;
+	      plt[1] = OR1K_ADD(12,12,16);
+	      plt[2] = OR1K_LWZ(12,12) | got;
+	      plt[3] = OR1K_MOVHI(11) | pltrelhi;
+	      plt[4] = OR1K_ORI(11,11) | pltrello;
+	      plt_insn_count = 5;
+	    }
+	  else
+	    {
+	      plt[0] = OR1K_LWZ(12,16) | got_offset;
+	      plt[1] = OR1K_ORI0(11) | plt_reloc;
+	      plt[2] = OR1K_NOP;
+	    }
 	}
       else
 	{
 	  unsigned ha = ((got_addr + 0x8000) >> 16) & 0xffff;
 	  unsigned lo = got_addr & 0xffff;
-	  plt0 = OR1K_MOVHI(12) | ha;
-	  plt1 = OR1K_LWZ(12,12) | lo;
-	  plt2 = OR1K_ORI0(11) | plt_reloc;
+	  plt[0] = OR1K_MOVHI(12) | ha;
+	  plt[1] = OR1K_LWZ(12,12) | lo;
+	  plt[2] = OR1K_ORI0(11) | plt_reloc;
+	}
+
+      /* For large code model we fixup the non-PIC PLT relocation instructions
+	 here.  */
+      if (large_plt_entry && !bfd_link_pic (info))
+	{
+	  unsigned pltrelhi = (plt_reloc >> 16) & 0xffff;
+	  unsigned pltrello = plt_reloc & 0xffff;
+
+	  plt[2] = OR1K_MOVHI(11) | pltrelhi;
+	  plt[3] = OR1K_ORI(11,11) | pltrello;
+	  plt[4] = OR1K_NOP;
+	  plt_insn_count = 5;
 	}
 
       or1k_write_plt_entry (output_bfd, splt->contents + h->plt.offset,
-			    plt0, plt1, plt2, OR1K_JR(12));
+			    OR1K_JR(12), plt, plt_insn_count);
 
       /* Fill in the entry in the global offset table.  We initialize it to
 	 point to the top of the plt.  This is done to lazy lookup the actual
@@ -2777,11 +2843,16 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
 	{
 	  asection *splt = htab->root.splt;
+	  bfd_vma plt_index;
+
+	  /* Track the index of our plt entry for use in calculating size.  */
+	  plt_index = htab->plt_count++;
+	  ((struct elf_or1k_link_hash_entry *) h)->plt_index = plt_index;
 
 	  /* If this is the first .plt entry, make room for the special
 	     first entry.  */
 	  if (splt->size == 0)
-	    splt->size = PLT_ENTRY_SIZE;
+	    splt->size = elf_or1k_plt_entry_size (plt_index);
 
 	  h->plt.offset = splt->size;
 
@@ -2798,7 +2869,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
 	    }
 
 	  /* Make room for this entry.  */
-	  splt->size += PLT_ENTRY_SIZE;
+	  splt->size += elf_or1k_plt_entry_size (plt_index);
 
 	  /* We also need to make an entry in the .got.plt section, which
 	     will be placed in the .got section by the linker script.  */
diff --git a/ld/testsuite/ld-or1k/gotha1.dd b/ld/testsuite/ld-or1k/gotha1.dd
new file mode 100644
index 00000000000..0ad1f8f5399
--- /dev/null
+++ b/ld/testsuite/ld-or1k/gotha1.dd
@@ -0,0 +1,34 @@
+
+.*\.x:     file format elf32-or1k
+
+
+Disassembly of section \.plt:
+
+[0-9a-f]+ <\.plt>:
+ +[0-9a-f]+:	19 80 00 00 	l\.movhi r12,0x0
+ +[0-9a-f]+:	85 ec [0-9a-f]+ [0-9a-f]+ 	l\.lwz r15,[0-9]+\(r12\)
+ +[0-9a-f]+:	44 00 78 00 	l\.jr r15
+ +[0-9a-f]+:	85 8c [0-9a-f]+ [0-9a-f]+ 	l\.lwz r12,[0-9]+\(r12\)
+ +[0-9a-f]+:	19 80 00 00 	l\.movhi r12,0x0
+ +[0-9a-f]+:	85 8c [0-9a-f]+ [0-9a-f]+ 	l\.lwz r12,[0-9]+\(r12\)
+ +[0-9a-f]+:	44 00 60 00 	l\.jr r12
+ +[0-9a-f]+:	a9 60 00 00 	l\.ori r11,r0,0x0
+
+Disassembly of section \.text:
+
+[0-9a-f]+ <_start>:
+ +[0-9a-f]+:	9c 21 ff fc 	l\.addi r1,r1,-4
+ +[0-9a-f]+:	d4 01 48 00 	l\.sw 0\(r1\),r9
+ +[0-9a-f]+:	04 00 00 02 	l\.jal [0-9a-f]+ <_start\+0x10>
+ +[0-9a-f]+:	1a 60 00 00 	l\.movhi r19,0x0
+ +[0-9a-f]+:	aa 73 [0-9a-f]+ [0-9a-f]+ 	l\.ori r19,r19,0x[0-9a-f]+
+ +[0-9a-f]+:	e2 73 48 00 	l\.add r19,r19,r9
+ +[0-9a-f]+:	1a 20 00 00 	l\.movhi r17,0x0
+ +[0-9a-f]+:	e2 31 98 00 	l\.add r17,r17,r19
+ +[0-9a-f]+:	86 31 00 10 	l\.lwz r17,16\(r17\)
+ +[0-9a-f]+:	84 71 00 00 	l\.lwz r3,0\(r17\)
+ +[0-9a-f]+:	07 ff ff f2 	l\.jal [0-9a-f]+ <\.plt\+0x10>
+ +[0-9a-f]+:	15 00 00 00 	l\.nop 0x0
+ +[0-9a-f]+:	85 21 00 00 	l\.lwz r9,0\(r1\)
+ +[0-9a-f]+:	44 00 48 00 	l\.jr r9
+ +[0-9a-f]+:	9c 21 00 04 	l\.addi r1,r1,4
diff --git a/ld/testsuite/ld-or1k/gotha1.s b/ld/testsuite/ld-or1k/gotha1.s
new file mode 100644
index 00000000000..42b16db425c
--- /dev/null
+++ b/ld/testsuite/ld-or1k/gotha1.s
@@ -0,0 +1,24 @@
+	.data
+	.p2align 16
+
+	.text
+	.globl	_start
+_start:
+	l.addi	r1, r1, -4
+	l.sw	0(r1), r9
+
+	l.jal	8
+	 l.movhi	r19, gotpchi(_GLOBAL_OFFSET_TABLE_-4)
+	l.ori	r19, r19, gotpclo(_GLOBAL_OFFSET_TABLE_+0)
+	l.add	r19, r19, r9
+
+	l.movhi	r17, gotha(x)
+	l.add	r17, r17, r19
+	l.lwz	r17, got(x)(r17)
+	l.lwz	r3, 0(r17)
+
+	l.jal	plt(func)
+	 l.nop
+	l.lwz	r9, 0(r1)
+	l.jr	r9
+	 l.addi	r1, r1, 4
diff --git a/ld/testsuite/ld-or1k/gotha2.dd b/ld/testsuite/ld-or1k/gotha2.dd
new file mode 100644
index 00000000000..fe09da5466b
--- /dev/null
+++ b/ld/testsuite/ld-or1k/gotha2.dd
@@ -0,0 +1,21 @@
+
+.*\.x:     file format elf32-or1k
+
+
+Disassembly of section \.text:
+
+[0-9a-f]+ <test>:
+ +[0-9a-f]+:	9c 21 ff f8 	l\.addi r1,r1,-8
+ +[0-9a-f]+:	d4 01 80 00 	l\.sw 0\(r1\),r16
+ +[0-9a-f]+:	d4 01 48 04 	l\.sw 4\(r1\),r9
+ +[0-9a-f]+:	04 00 [0-9a-f]+ [0-9a-f]+ 	l\.jal [0-9a-f]+ <test\+0x14>
+ +[0-9a-f]+:	1a 00 00 00 	l\.movhi r16,0x0
+ +[0-9a-f]+:	aa 10 [0-9a-f]+ [0-9a-f]+ 	l\.ori r16,r16,0x[0-9a-f]+
+ +[0-9a-f]+:	e2 10 48 00 	l\.add r16,r16,r9
+ +[0-9a-f]+:	1a 20 00 00 	l\.movhi r17,0x0
+ +[0-9a-f]+:	e2 31 80 00 	l\.add r17,r17,r16
+ +[0-9a-f]+:	86 31 00 0c 	l\.lwz r17,12\(r17\)
+ +[0-9a-f]+:	85 21 00 04 	l\.lwz r9,4\(r1\)
+ +[0-9a-f]+:	86 01 00 00 	l\.lwz r16,0\(r1\)
+ +[0-9a-f]+:	44 00 48 00 	l\.jr r9
+ +[0-9a-f]+:	9c 21 00 08 	l\.addi r1,r1,8
diff --git a/ld/testsuite/ld-or1k/gotha2.s b/ld/testsuite/ld-or1k/gotha2.s
new file mode 100644
index 00000000000..164b282f2dd
--- /dev/null
+++ b/ld/testsuite/ld-or1k/gotha2.s
@@ -0,0 +1,22 @@
+	.section	.text
+	.align 4
+	.global	test
+	.type	test, @function
+test:
+	l.addi	r1, r1, -8
+	l.sw	0(r1), r16
+	l.sw	4(r1), r9
+
+	l.jal	8
+	 l.movhi	r16, gotpchi(_GLOBAL_OFFSET_TABLE_-4)
+	l.ori	r16, r16, gotpclo(_GLOBAL_OFFSET_TABLE_+0)
+	l.add	r16, r16, r9
+
+	l.movhi	r17, gotha(i)
+	l.add	r17, r17, r16
+	l.lwz	r17, got(i)(r17)
+
+	l.lwz	r9, 4(r1)
+	l.lwz	r16, 0(r1)
+	l.jr	r9
+	 l.addi	r1, r1, 8
diff --git a/ld/testsuite/ld-or1k/or1k.exp b/ld/testsuite/ld-or1k/or1k.exp
index 8bb943aacc9..f10949e89aa 100644
--- a/ld/testsuite/ld-or1k/or1k.exp
+++ b/ld/testsuite/ld-or1k/or1k.exp
@@ -53,6 +53,14 @@ set or1kplttests {
      "" {plt1.s}
      {{objdump -dr plt1.x.dd}}
      "plt1.x"}
+    {"gotha exec plt" "tmpdir/libpltlib.so" ""
+     "" {gotha1.s}
+     {{objdump -dr gotha1.dd}}
+     "gotha1.x"}
+    {"gotha -fpic -shared" "-fpic -shared" ""
+     "" {gotha2.s}
+     {{objdump -dr gotha2.dd}}
+     "gotha2.x"}
 }
 
 # Not implemented yet
diff --git a/ld/testsuite/ld-or1k/pltlib.s b/ld/testsuite/ld-or1k/pltlib.s
index baf76ca1af7..8b4d7ba48fd 100644
--- a/ld/testsuite/ld-or1k/pltlib.s
+++ b/ld/testsuite/ld-or1k/pltlib.s
@@ -1,5 +1,6 @@
 	.section .data
 	.globl x, y
+	.size x, 4
 x:	.long 33
 y:	.long 44
 
-- 
2.26.2

[OpenRISC] [PATCH v2 0/4] OpenRISC large binary fixes

[Giulio Benetti]

Hi Stafford,

I've just back-ported to binutils 2.36.1 and tested in conjunction with 
your gcc patches for -mcmodel=large and it works perfectly while 
building libgeos. I've also checked with and without -mcmodel=large and
it works correctly since without it it fails and with it it links correctly.

I'm going to back port it to:
2.32
2.34
2.35.2
too.

Thanks a lot and
best regards
-- 
Giulio Benetti
Benetti Engineering sas

On 5/1/21 11:02 PM, Stafford Horne wrote:
> Changes since v1:
>   - Replaced patches 3/4 with a different approach.  Instead of relying on seeing
>     R_OR1K_GOT_AHI16 relocations to enable large plts, I just track the PLT entry
>     count and switch to large PLT when we detect the overflow will occur.
>   - Patch "Avoid R_OR1K_GOT16 overflow failures in presence of R_OR1K_GOT_AHI16"
>     is the actual bug fix for 21464, which was missed in the original series.  We
>     inhibit truncation detection when the low got() relocation is paired with the
>     new high gotha() relocation.
> 
> These are several fixes to OpenRISC BFD to handle issues mostly related to
> linking large files.
> 
> There will be a GCC patch then depends on this, a new -mcmodel=large argument is
> added to GCC to allow creating GOT relocation values larger than 64k.
> 
> The series fixes 3 issues:
> 
>   * PR 27624 - Assertion failure when dynamic symol is localized
>   * PR 21464 - GOT relocation truncation.
>   * PR 27746 - Issue with silent overlows in PLT code.
> 
> Stafford Horne (4):
>    or1k: Fix issue with plt link failure for local calls
>    or1k: Implement relocation R_OR1K_GOT_AHI16 for gotha()
>    or1k: Avoid R_OR1K_GOT16 overflow failures in presence of
>      R_OR1K_GOT_AHI16
>    or1k: Support large plt_relocs when generating plt entries
> 
>   bfd/bfd-in2.h                    |   1 +
>   bfd/elf32-or1k.c                 | 190 +++++++++++++++++++++++--------
>   bfd/libbfd.h                     |   1 +
>   bfd/reloc.c                      |   2 +
>   cpu/or1k.opc                     |   7 +-
>   gas/testsuite/gas/or1k/reloc-1.d |   4 +-
>   gas/testsuite/gas/or1k/reloc-1.s |   4 +
>   include/elf/or1k.h               |   1 +
>   ld/testsuite/ld-or1k/gotha1.dd   |  34 ++++++
>   ld/testsuite/ld-or1k/gotha1.s    |  24 ++++
>   ld/testsuite/ld-or1k/gotha2.dd   |  21 ++++
>   ld/testsuite/ld-or1k/gotha2.s    |  22 ++++
>   ld/testsuite/ld-or1k/or1k.exp    |   8 ++
>   ld/testsuite/ld-or1k/pltlib.s    |   1 +
>   opcodes/or1k-asm.c               |   7 +-
>   15 files changed, 279 insertions(+), 48 deletions(-)
>   create mode 100644 ld/testsuite/ld-or1k/gotha1.dd
>   create mode 100644 ld/testsuite/ld-or1k/gotha1.s
>   create mode 100644 ld/testsuite/ld-or1k/gotha2.dd
>   create mode 100644 ld/testsuite/ld-or1k/gotha2.s
> 

[OpenRISC] [PATCH v2 0/4] OpenRISC large binary fixes

[Giulio Benetti]

Hi Stafford, All,

I've backported this patchset for Buildroot to versions:
- 2.32
- 2.34
- 2.35.2
- 2.36.1

Does it make sense to send them? I don't know if those version will have 
minor versions where these backported patches can be applied.

Best regards
-- 
Giulio Benetti
Benetti Engineering sas

On 5/1/21 11:02 PM, Stafford Horne wrote:
> Changes since v1:
>   - Replaced patches 3/4 with a different approach.  Instead of relying on seeing
>     R_OR1K_GOT_AHI16 relocations to enable large plts, I just track the PLT entry
>     count and switch to large PLT when we detect the overflow will occur.
>   - Patch "Avoid R_OR1K_GOT16 overflow failures in presence of R_OR1K_GOT_AHI16"
>     is the actual bug fix for 21464, which was missed in the original series.  We
>     inhibit truncation detection when the low got() relocation is paired with the
>     new high gotha() relocation.
> 
> These are several fixes to OpenRISC BFD to handle issues mostly related to
> linking large files.
> 
> There will be a GCC patch then depends on this, a new -mcmodel=large argument is
> added to GCC to allow creating GOT relocation values larger than 64k.
> 
> The series fixes 3 issues:
> 
>   * PR 27624 - Assertion failure when dynamic symol is localized
>   * PR 21464 - GOT relocation truncation.
>   * PR 27746 - Issue with silent overlows in PLT code.
> 
> Stafford Horne (4):
>    or1k: Fix issue with plt link failure for local calls
>    or1k: Implement relocation R_OR1K_GOT_AHI16 for gotha()
>    or1k: Avoid R_OR1K_GOT16 overflow failures in presence of
>      R_OR1K_GOT_AHI16
>    or1k: Support large plt_relocs when generating plt entries
> 
>   bfd/bfd-in2.h                    |   1 +
>   bfd/elf32-or1k.c                 | 190 +++++++++++++++++++++++--------
>   bfd/libbfd.h                     |   1 +
>   bfd/reloc.c                      |   2 +
>   cpu/or1k.opc                     |   7 +-
>   gas/testsuite/gas/or1k/reloc-1.d |   4 +-
>   gas/testsuite/gas/or1k/reloc-1.s |   4 +
>   include/elf/or1k.h               |   1 +
>   ld/testsuite/ld-or1k/gotha1.dd   |  34 ++++++
>   ld/testsuite/ld-or1k/gotha1.s    |  24 ++++
>   ld/testsuite/ld-or1k/gotha2.dd   |  21 ++++
>   ld/testsuite/ld-or1k/gotha2.s    |  22 ++++
>   ld/testsuite/ld-or1k/or1k.exp    |   8 ++
>   ld/testsuite/ld-or1k/pltlib.s    |   1 +
>   opcodes/or1k-asm.c               |   7 +-
>   15 files changed, 279 insertions(+), 48 deletions(-)
>   create mode 100644 ld/testsuite/ld-or1k/gotha1.dd
>   create mode 100644 ld/testsuite/ld-or1k/gotha1.s
>   create mode 100644 ld/testsuite/ld-or1k/gotha2.dd
>   create mode 100644 ld/testsuite/ld-or1k/gotha2.s
>