Merge GDB 7.5.1

bfd/elf-m10300.c

 /* Matsushita 10300 specific support for 32-bit ELF
    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-   2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+   2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 48 matching lines @@
    instructions.  */
 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
 
 /* Used to mark functions which have had redundant parts of their
    prologue deleted.  */
 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
   unsigned char flags;
 
   /* Calculated value.  */
   bfd_vma value;
+
+#define GOT_UNKNOWN     0
+#define GOT_NORMAL      1
+#define GOT_TLS_GD      2
+#define GOT_TLS_LD      3
+#define GOT_TLS_IE      4
+  /* Used to distinguish GOT entries for TLS types from normal GOT entries.  */
+  unsigned char tls_type;
 };
 
 /* We derive a hash table from the main elf linker hash table so
    we can store state variables and a secondary hash table without
    resorting to global variables.  */
 struct elf32_mn10300_link_hash_table
 {
   /* The main hash table.  */
   struct elf_link_hash_table root;
 
   /* A hash table for static functions.  We could derive a new hash table
      instead of using the full elf32_mn10300_link_hash_table if we wanted
      to save some memory.  */
   struct elf32_mn10300_link_hash_table *static_hash_table;
 
   /* Random linker state flags.  */
 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
   char flags;
+  struct
+  {
+    bfd_signed_vma  refcount;
+    bfd_vma         offset;
+    char            got_allocated;
+    char            rel_emitted;
+  } tls_ldm_got;
 };
 
+#define elf_mn10300_hash_entry(ent) ((struct elf32_mn10300_link_hash_entry *)(ent))
+
+struct elf_mn10300_obj_tdata
+{
+  struct elf_obj_tdata root;
+
+  /* tls_type for each local got entry.  */
+  char * local_got_tls_type;
+};
+
+#define elf_mn10300_tdata(abfd) \
+  ((struct elf_mn10300_obj_tdata *) (abfd)->tdata.any)
+
+#define elf_mn10300_local_got_tls_type(abfd) \
+  (elf_mn10300_tdata (abfd)->local_got_tls_type)
+
 #ifndef streq
 #define streq(a, b) (strcmp ((a),(b)) == 0)
 #endif
 
 /* For MN10300 linker hash table.  */
 
 /* Get the MN10300 ELF linker hash table from a link_info structure.  */
 
 #define elf32_mn10300_hash_table(p) \
   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
@@ skipping 339 matching lines @@
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_bitfield, /* complain_on_overflow */
          bfd_elf_generic_reloc, /* */
          "R_MN10300_RELATIVE",  /* name */
          FALSE,                 /* partial_inplace */
          0xffffffff,            /* src_mask */
          0xffffffff,            /* dst_mask */
          FALSE),                /* pcrel_offset */
 
-  EMPTY_HOWTO (24),
-  EMPTY_HOWTO (25),
-  EMPTY_HOWTO (26),
-  EMPTY_HOWTO (27),
-  EMPTY_HOWTO (28),
-  EMPTY_HOWTO (29),
-  EMPTY_HOWTO (30),
-  EMPTY_HOWTO (31),
-  EMPTY_HOWTO (32),
+  HOWTO (R_MN10300_TLS_GD,      /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_GD",    /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_LD,      /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_LD",    /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_LDO,     /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_LDO",   /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_GOTIE,   /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_GOTIE", /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_IE,      /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_IE",    /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_LE,      /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_LE",    /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_DTPMOD,  /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_DTPMOD",        /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_DTPOFF,  /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_DTPOFF",        /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
+
+  HOWTO (R_MN10300_TLS_TPOFF,   /* type */
+         0,                     /* rightshift */
+         2,                     /* size (0 = byte, 1 = short, 2 = long) */
+         32,                    /* bitsize */
+         FALSE,                 /* pc_relative */
+         0,                     /* bitpos */
+         complain_overflow_bitfield, /* complain_on_overflow */
+         bfd_elf_generic_reloc, /* */
+         "R_MN10300_TLS_TPOFF", /* name */
+         FALSE,                 /* partial_inplace */
+         0xffffffff,            /* src_mask */
+         0xffffffff,            /* dst_mask */
+         FALSE),                /* pcrel_offset */
   
   HOWTO (R_MN10300_SYM_DIFF,    /* type */
          0,                     /* rightshift */
          2,                     /* size (0 = byte, 1 = short, 2 = long) */
          32,                    /* bitsize */
          FALSE,                 /* pc_relative */
          0,                     /* bitpos */
          complain_overflow_dont,/* complain_on_overflow */
          NULL,                  /* special handler.  */
          "R_MN10300_SYM_DIFF",  /* name */
@@ skipping 42 matching lines @@
   { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
   { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
   { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
   { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
   { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
   { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
   { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
   { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
   { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
   { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
+  { BFD_RELOC_MN10300_TLS_GD, R_MN10300_TLS_GD },
+  { BFD_RELOC_MN10300_TLS_LD, R_MN10300_TLS_LD },
+  { BFD_RELOC_MN10300_TLS_LDO, R_MN10300_TLS_LDO },
+  { BFD_RELOC_MN10300_TLS_GOTIE, R_MN10300_TLS_GOTIE },
+  { BFD_RELOC_MN10300_TLS_IE, R_MN10300_TLS_IE },
+  { BFD_RELOC_MN10300_TLS_LE, R_MN10300_TLS_LE },
+  { BFD_RELOC_MN10300_TLS_DTPMOD, R_MN10300_TLS_DTPMOD },
+  { BFD_RELOC_MN10300_TLS_DTPOFF, R_MN10300_TLS_DTPOFF },
+  { BFD_RELOC_MN10300_TLS_TPOFF, R_MN10300_TLS_TPOFF },
   { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
   { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
 };
 
 /* Create the GOT section.  */
 
 static bfd_boolean
 _bfd_mn10300_elf_create_got_section (bfd * abfd,
                                      struct bfd_link_info * info)
 {
   flagword   flags;
   flagword   pltflags;
   asection * s;
   struct elf_link_hash_entry * h;
   const struct elf_backend_data * bed = get_elf_backend_data (abfd);
+  struct elf_link_hash_table *htab;
   int ptralign;
 
   /* This function may be called more than once.  */
-  if (bfd_get_section_by_name (abfd, ".got") != NULL)
+  htab = elf_hash_table (info);
+  if (htab->sgot != NULL)
     return TRUE;
 
   switch (bed->s->arch_size)
     {
     case 32:
       ptralign = 2;
       break;
 
     case 64:
       ptralign = 3;
       break;
 
     default:
       bfd_set_error (bfd_error_bad_value);
       return FALSE;
     }
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
            | SEC_LINKER_CREATED);
 
   pltflags = flags;
   pltflags |= SEC_CODE;
   if (bed->plt_not_loaded)
     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
   if (bed->plt_readonly)
     pltflags |= SEC_READONLY;
 
-  s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
+  s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
+  htab->splt = s;
   if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
     return FALSE;
 
   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
      .plt section.  */
   if (bed->want_plt_sym)
     {
       h = _bfd_elf_define_linkage_sym (abfd, info, s,
                                        "_PROCEDURE_LINKAGE_TABLE_");
-      elf_hash_table (info)->hplt = h;
+      htab->hplt = h;
       if (h == NULL)
         return FALSE;
     }
 
-  s = bfd_make_section_with_flags (abfd, ".got", flags);
+  s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
+  htab->sgot = s;
   if (s == NULL
       || ! bfd_set_section_alignment (abfd, s, ptralign))
     return FALSE;
 
   if (bed->want_got_plt)
     {
-      s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
+      s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
+      htab->sgotplt = s;
       if (s == NULL
           || ! bfd_set_section_alignment (abfd, s, ptralign))
         return FALSE;
     }
 
   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
      (or .got.plt) section.  We don't do this in the linker script
      because we don't want to define the symbol if we are not creating
      a global offset table.  */
   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
-  elf_hash_table (info)->hgot = h;
+  htab->hgot = h;
   if (h == NULL)
     return FALSE;
 
   /* The first bit of the global offset table is the header.  */
   s->size += bed->got_header_size;
 
   return TRUE;
 }
 
 static reloc_howto_type *
@@ skipping 30 matching lines @@
                        arelent *cache_ptr,
                        Elf_Internal_Rela *dst)
 {
   unsigned int r_type;
 
   r_type = ELF32_R_TYPE (dst->r_info);
   BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
   cache_ptr->howto = elf_mn10300_howto_table + r_type;
 }
 
+static int
+elf_mn10300_tls_transition (struct bfd_link_info *        info,
+                            int                           r_type,
+                            struct elf_link_hash_entry *  h,
+                            asection *                    sec,
+                            bfd_boolean                   counting)
+{
+  bfd_boolean is_local;
+
+  if (r_type == R_MN10300_TLS_GD
+      && h != NULL
+      && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
+    return R_MN10300_TLS_GOTIE;
+
+  if (info->shared)
+    return r_type;
+
+  if (! (sec->flags & SEC_CODE))
+    return r_type;
+
+  if (! counting && h != NULL && ! elf_hash_table (info)->dynamic_sections_created)
+    is_local = TRUE;
+  else
+    is_local = SYMBOL_CALLS_LOCAL (info, h);
+
+  /* For the main program, these are the transitions we do.  */
+  switch (r_type)
+    {
+    case R_MN10300_TLS_GD: return is_local ? R_MN10300_TLS_LE : R_MN10300_TLS_GOTIE;
+    case R_MN10300_TLS_LD: return R_MN10300_NONE;
+    case R_MN10300_TLS_LDO: return R_MN10300_TLS_LE;
+    case R_MN10300_TLS_IE:
+    case R_MN10300_TLS_GOTIE: return is_local ? R_MN10300_TLS_LE : r_type;
+    }
+
+  return r_type;
+}
+
+/* Return the relocation value for @tpoff relocation
+   if STT_TLS virtual address is ADDRESS.  */
+
+static bfd_vma
+dtpoff (struct bfd_link_info * info, bfd_vma address)
+{
+  struct elf_link_hash_table *htab = elf_hash_table (info);
+
+  /* If tls_sec is NULL, we should have signalled an error already.  */
+  if (htab->tls_sec == NULL)
+    return 0;
+  return address - htab->tls_sec->vma;
+}
+
+/* Return the relocation value for @tpoff relocation
+   if STT_TLS virtual address is ADDRESS.  */
+
+static bfd_vma
+tpoff (struct bfd_link_info * info, bfd_vma address)
+{
+  struct elf_link_hash_table *htab = elf_hash_table (info);
+
+  /* If tls_sec is NULL, we should have signalled an error already.  */
+  if (htab->tls_sec == NULL)
+    return 0;
+  return address - (htab->tls_size + htab->tls_sec->vma);
+}
+
+/* Returns nonzero if there's a R_MN10300_PLT32 reloc that we now need
+   to skip, after this one.  The actual value is the offset between
+   this reloc and the PLT reloc.  */
+
+static int
+mn10300_do_tls_transition (bfd *         input_bfd,
+                           unsigned int  r_type,
+                           unsigned int  tls_r_type,
+                           bfd_byte *    contents,
+                           bfd_vma       offset)
+{
+  bfd_byte *op = contents + offset;
+  int gotreg = 0;
+
+#define TLS_PAIR(r1,r2) ((r1) * R_MN10300_MAX + (r2))
+
+  /* This is common to all GD/LD transitions, so break it out.  */
+  if (r_type == R_MN10300_TLS_GD
+      || r_type == R_MN10300_TLS_LD)
+    {
+      op -= 2;
+      /* mov imm,d0.  */
+      BFD_ASSERT (bfd_get_8 (input_bfd, op) == 0xFC);
+      BFD_ASSERT (bfd_get_8 (input_bfd, op + 1) == 0xCC);
+      /* add aN,d0.  */
+      BFD_ASSERT (bfd_get_8 (input_bfd, op + 6) == 0xF1);
+      gotreg = (bfd_get_8 (input_bfd, op + 7) & 0x0c) >> 2;
+      /* Call.  */
+      BFD_ASSERT (bfd_get_8 (input_bfd, op + 8) == 0xDD);
+    }
+
+  switch (TLS_PAIR (r_type, tls_r_type))
+    {
+    case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_GOTIE):
+      {
+        /* Keep track of which register we put GOTptr in.  */
+        /* mov (_x@indntpoff,a2),a0.  */
+        memcpy (op, "\xFC\x20\x00\x00\x00\x00", 6);
+        op[1] |= gotreg;
+        /* add e2,a0.  */
+        memcpy (op+6, "\xF9\x78\x28", 3);
+        /* or  0x00000000, d0 - six byte nop.  */
+        memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
+      }
+      return 7;
+
+    case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_LE):
+      {
+        /* Register is *always* a0.  */
+        /* mov _x@tpoff,a0.  */
+        memcpy (op, "\xFC\xDC\x00\x00\x00\x00", 6);
+        /* add e2,a0.  */
+        memcpy (op+6, "\xF9\x78\x28", 3);
+        /* or  0x00000000, d0 - six byte nop.  */
+        memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
+      }
+      return 7;
+    case TLS_PAIR (R_MN10300_TLS_LD, R_MN10300_NONE):
+      {
+        /* Register is *always* a0.  */
+        /* mov e2,a0.  */
+        memcpy (op, "\xF5\x88", 2);
+        /* or  0x00000000, d0 - six byte nop.  */
+        memcpy (op+2, "\xFC\xE4\x00\x00\x00\x00", 6);
+        /* or  0x00000000, e2 - seven byte nop.  */
+        memcpy (op+8, "\xFE\x19\x22\x00\x00\x00\x00", 7);
+      }
+      return 7;
+
+    case TLS_PAIR (R_MN10300_TLS_LDO, R_MN10300_TLS_LE):
+      /* No changes needed, just the reloc change.  */
+      return 0;
+
+    /*  These are a little tricky, because we have to detect which
+        opcode is being used (they're different sizes, with the reloc
+        at different offsets within the opcode) and convert each
+        accordingly, copying the operands as needed.  The conversions
+        we do are as follows (IE,GOTIE,LE):
+
+                   1111 1100  1010 01Dn  [-- abs32 --]  MOV (x@indntpoff),Dn
+                   1111 1100  0000 DnAm  [-- abs32 --]  MOV (x@gotntpoff,Am),Dn
+                   1111 1100  1100 11Dn  [-- abs32 --]  MOV x@tpoff,Dn
+
+                   1111 1100  1010 00An  [-- abs32 --]  MOV (x@indntpoff),An
+                   1111 1100  0010 AnAm  [-- abs32 --]  MOV (x@gotntpoff,Am),An
+                   1111 1100  1101 11An  [-- abs32 --]  MOV x@tpoff,An
+
+        1111 1110  0000 1110  Rnnn Xxxx  [-- abs32 --]  MOV (x@indntpoff),Rn
+        1111 1110  0000 1010  Rnnn Rmmm  [-- abs32 --]  MOV (x@indntpoff,Rm),Rn
+        1111 1110  0000 1000  Rnnn Xxxx  [-- abs32 --]  MOV x@tpoff,Rn
+
+        Since the GOT pointer is always $a2, we assume the last
+        normally won't happen, but let's be paranoid and plan for the
+        day that GCC optimizes it somewhow.  */
+
+    case TLS_PAIR (R_MN10300_TLS_IE, R_MN10300_TLS_LE):
+      if (op[-2] == 0xFC)
+        {
+          op -= 2;
+          if ((op[1] & 0xFC) == 0xA4) /* Dn */
+            {
+              op[1] &= 0x03; /* Leaves Dn.  */
+              op[1] |= 0xCC;
+            }
+          else /* An */
+            {
+              op[1] &= 0x03; /* Leaves An. */
+              op[1] |= 0xDC;
+            }
+        }
+      else if (op[-3] == 0xFE)
+        op[-2] = 0x08;
+      else
+        abort ();
+      break;
+
+    case TLS_PAIR (R_MN10300_TLS_GOTIE, R_MN10300_TLS_LE):
+      if (op[-2] == 0xFC)
+        {
+          op -= 2;
+          if ((op[1] & 0xF0) == 0x00) /* Dn */
+            {
+              op[1] &= 0x0C; /* Leaves Dn.  */
+              op[1] >>= 2;
+              op[1] |= 0xCC;
+            }
+          else /* An */
+            {
+              op[1] &= 0x0C; /* Leaves An.  */
+              op[1] >>= 2;
+              op[1] |= 0xDC;
+            }
+        }
+      else if (op[-3] == 0xFE)
+        op[-2] = 0x08;
+      else
+        abort ();
+      break;
+
+    default:
+      (*_bfd_error_handler)
+        (_("%s: Unsupported transition from %s to %s"),
+         bfd_get_filename (input_bfd),
+         elf_mn10300_howto_table[r_type].name,
+         elf_mn10300_howto_table[tls_r_type].name);
+      break;
+    }
+#undef TLS_PAIR
+  return 0;
+}
+
 /* Look through the relocs for a section during the first phase.
    Since we don't do .gots or .plts, we just need to consider the
    virtual table relocs for gc.  */
 
 static bfd_boolean
 mn10300_elf_check_relocs (bfd *abfd,
                           struct bfd_link_info *info,
                           asection *sec,
                           const Elf_Internal_Rela *relocs)
 {
+  struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
   bfd_boolean sym_diff_reloc_seen;
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Sym * isymbuf = NULL;
   struct elf_link_hash_entry **sym_hashes;
   const Elf_Internal_Rela *rel;
   const Elf_Internal_Rela *rel_end;
   bfd *      dynobj;
   bfd_vma *  local_got_offsets;
   asection * sgot;
   asection * srelgot;
@@ skipping 14 matching lines @@
   dynobj = elf_hash_table (info)->dynobj;
   local_got_offsets = elf_local_got_offsets (abfd);
   rel_end = relocs + sec->reloc_count;
   sym_diff_reloc_seen = FALSE;
 
   for (rel = relocs; rel < rel_end; rel++)
     {
       struct elf_link_hash_entry *h;
       unsigned long r_symndx;
       unsigned int r_type;
+      int tls_type = GOT_NORMAL;
 
       r_symndx = ELF32_R_SYM (rel->r_info);
       if (r_symndx < symtab_hdr->sh_info)
         h = NULL;
       else
         {
           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
           while (h->root.type == bfd_link_hash_indirect
                  || h->root.type == bfd_link_hash_warning)
             h = (struct elf_link_hash_entry *) h->root.u.i.link;
         }
 
       r_type = ELF32_R_TYPE (rel->r_info);
+      r_type = elf_mn10300_tls_transition (info, r_type, h, sec, TRUE);
 
       /* Some relocs require a global offset table.  */
       if (dynobj == NULL)
         {
           switch (r_type)
             {
             case R_MN10300_GOT32:
             case R_MN10300_GOT24:
             case R_MN10300_GOT16:
             case R_MN10300_GOTOFF32:
             case R_MN10300_GOTOFF24:
             case R_MN10300_GOTOFF16:
             case R_MN10300_GOTPC32:
             case R_MN10300_GOTPC16:
+            case R_MN10300_TLS_GD:
+            case R_MN10300_TLS_LD:
+            case R_MN10300_TLS_GOTIE:
+            case R_MN10300_TLS_IE:
               elf_hash_table (info)->dynobj = dynobj = abfd;
               if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
                 goto fail;
               break;
 
             default:
               break;
             }
         }
 
       switch (r_type)
         {
         /* This relocation describes the C++ object vtable hierarchy.
            Reconstruct it for later use during GC.  */
         case R_MN10300_GNU_VTINHERIT:
           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
             goto fail;
           break;
 
         /* This relocation describes which C++ vtable entries are actually
            used.  Record for later use during GC.  */
         case R_MN10300_GNU_VTENTRY:
           BFD_ASSERT (h != NULL);
           if (h != NULL
               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
             goto fail;
           break;
 
+        case R_MN10300_TLS_LD:
+          htab->tls_ldm_got.refcount ++;
+          tls_type = GOT_TLS_LD;
+
+          if (htab->tls_ldm_got.got_allocated)
+            break;
+          goto create_got;
+
+        case R_MN10300_TLS_IE:
+        case R_MN10300_TLS_GOTIE:
+          if (info->shared)
+            info->flags |= DF_STATIC_TLS;
+          /* Fall through */
+          
+        case R_MN10300_TLS_GD:
         case R_MN10300_GOT32:
         case R_MN10300_GOT24:
         case R_MN10300_GOT16:
+        create_got:
           /* This symbol requires a global offset table entry.  */
 
+          switch (r_type)
+            {
+            case R_MN10300_TLS_IE:
+            case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break;
+            case R_MN10300_TLS_GD:    tls_type = GOT_TLS_GD; break;
+            default:                  tls_type = GOT_NORMAL; break;
+            }
+
           if (sgot == NULL)
             {
-              sgot = bfd_get_section_by_name (dynobj, ".got");
+              sgot = htab->root.sgot;
               BFD_ASSERT (sgot != NULL);
             }
 
           if (srelgot == NULL
               && (h != NULL || info->shared))
             {
-              srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+              srelgot = bfd_get_linker_section (dynobj, ".rela.got");
               if (srelgot == NULL)
                 {
-                  srelgot = bfd_make_section_with_flags (dynobj,
-                                                         ".rela.got",
-                                                         (SEC_ALLOC
-                                                          | SEC_LOAD
-                                                          | SEC_HAS_CONTENTS
-                                                          | SEC_IN_MEMORY
-                                                          | SEC_LINKER_CREATED
-                                                          | SEC_READONLY));
+                  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
+                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
+                                    | SEC_READONLY);
+                  srelgot = bfd_make_section_anyway_with_flags (dynobj,
+                                                                ".rela.got",
+                                                                flags);
                   if (srelgot == NULL
                       || ! bfd_set_section_alignment (dynobj, srelgot, 2))
                     goto fail;
                 }
             }
 
-          if (h != NULL)
+          if (r_type == R_MN10300_TLS_LD)
             {
+              htab->tls_ldm_got.offset = sgot->size;
+              htab->tls_ldm_got.got_allocated ++;
+            }
+          else if (h != NULL)
+            {
+              if (elf_mn10300_hash_entry (h)->tls_type != tls_type
+                  && elf_mn10300_hash_entry (h)->tls_type != GOT_UNKNOWN)
+                {
+                  if (tls_type == GOT_TLS_IE
+                      && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_GD)
+                    /* No change - this is ok.  */;
+                  else if (tls_type == GOT_TLS_GD
+                      && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
+                    /* Transition GD->IE.  */
+                    tls_type = GOT_TLS_IE;
+                  else
+                    (*_bfd_error_handler)
+                      (_("%B: %s' accessed both as normal and thread local symbol"),
+                       abfd, h ? h->root.root.string : "<local>");
+                }
+
+              elf_mn10300_hash_entry (h)->tls_type = tls_type;
+
               if (h->got.offset != (bfd_vma) -1)
                 /* We have already allocated space in the .got.  */
                 break;
 
               h->got.offset = sgot->size;
 
-              /* Make sure this symbol is output as a dynamic symbol.  */
-              if (h->dynindx == -1)
+              if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
+                  /* Make sure this symbol is output as a dynamic symbol.  */
+                  && h->dynindx == -1)
                 {
                   if (! bfd_elf_link_record_dynamic_symbol (info, h))
                     goto fail;
                 }
 
               srelgot->size += sizeof (Elf32_External_Rela);
+              if (r_type == R_MN10300_TLS_GD)
+                srelgot->size += sizeof (Elf32_External_Rela);
             }
           else
             {
               /* This is a global offset table entry for a local
                  symbol.  */
               if (local_got_offsets == NULL)
                 {
                   size_t       size;
                   unsigned int i;
 
-                  size = symtab_hdr->sh_info * sizeof (bfd_vma);
+                  size = symtab_hdr->sh_info * (sizeof (bfd_vma) + sizeof (char));
                   local_got_offsets = bfd_alloc (abfd, size);
 
                   if (local_got_offsets == NULL)
                     goto fail;
 
                   elf_local_got_offsets (abfd) = local_got_offsets;
+                  elf_mn10300_local_got_tls_type (abfd)
+                      = (char *) (local_got_offsets + symtab_hdr->sh_info);
 
                   for (i = 0; i < symtab_hdr->sh_info; i++)
                     local_got_offsets[i] = (bfd_vma) -1;
                 }
 
               if (local_got_offsets[r_symndx] != (bfd_vma) -1)
                 /* We have already allocated space in the .got.  */
                 break;
 
               local_got_offsets[r_symndx] = sgot->size;
 
               if (info->shared)
-                /* If we are generating a shared object, we need to
-                   output a R_MN10300_RELATIVE reloc so that the dynamic
-                   linker can adjust this GOT entry.  */
-                srelgot->size += sizeof (Elf32_External_Rela);
+                {
+                  /* If we are generating a shared object, we need to
+                     output a R_MN10300_RELATIVE reloc so that the dynamic
+                     linker can adjust this GOT entry.  */
+                  srelgot->size += sizeof (Elf32_External_Rela);
+
+                  if (r_type == R_MN10300_TLS_GD)
+                    /* And a R_MN10300_TLS_DTPOFF reloc as well.  */
+                    srelgot->size += sizeof (Elf32_External_Rela);
+                }
+
+              elf_mn10300_local_got_tls_type (abfd) [r_symndx] = tls_type;
             }
 
           sgot->size += 4;
-          break;
+          if (r_type == R_MN10300_TLS_GD
+              || r_type == R_MN10300_TLS_LD)
+            sgot->size += 4;
+
+          goto need_shared_relocs;
 
         case R_MN10300_PLT32:
         case R_MN10300_PLT16:
           /* This symbol requires a procedure linkage table entry.  We
              actually build the entry in adjust_dynamic_symbol,
              because this might be a case of linking PIC code which is
              never referenced by a dynamic object, in which case we
              don't need to generate a procedure linkage table entry
              after all.  */
 
@@ skipping 20 matching lines @@
           break;
 
         case R_MN10300_SYM_DIFF:
           sym_diff_reloc_seen = TRUE;
           break;
 
         case R_MN10300_32:
           if (h != NULL)
             h->non_got_ref = 1;
 
+        need_shared_relocs:
           /* If we are creating a shared library, then we
              need to copy the reloc into the shared library.  */
           if (info->shared
               && (sec->flags & SEC_ALLOC) != 0
               /* Do not generate a dynamic reloc for a
                  reloc associated with a SYM_DIFF operation.  */
               && ! sym_diff_reloc_seen)
             {
               asection * sym_section = NULL;
 
@@ skipping 88 matching lines @@
                                  bfd_byte *contents,
                                  bfd_vma offset,
                                  bfd_vma value,
                                  bfd_vma addend,
                                  struct elf_link_hash_entry * h,
                                  unsigned long symndx,
                                  struct bfd_link_info *info,
                                  asection *sym_sec ATTRIBUTE_UNUSED,
                                  int is_local ATTRIBUTE_UNUSED)
 {
+  struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
   static asection *  sym_diff_section;
   static bfd_vma     sym_diff_value;
   bfd_boolean is_sym_diff_reloc;
   unsigned long r_type = howto->type;
   bfd_byte * hit_data = contents + offset;
   bfd *      dynobj;
   asection * sgot;
   asection * splt;
   asection * sreloc;
 
@@ skipping 11 matching lines @@
     case R_MN10300_PCREL16:
     case R_MN10300_PCREL32:
     case R_MN10300_GOTOFF32:
     case R_MN10300_GOTOFF24:
     case R_MN10300_GOTOFF16:
       if (info->shared
           && (input_section->flags & SEC_ALLOC) != 0
           && h != NULL
           && ! SYMBOL_REFERENCES_LOCAL (info, h))
         return bfd_reloc_dangerous;
+    case R_MN10300_GOT32:
+      /* Issue 2052223:
+         Taking the address of a protected function in a shared library
+         is illegal.  Issue an error message here.  */
+      if (info->shared
+          && (input_section->flags & SEC_ALLOC) != 0
+          && h != NULL
+          && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
+          && (h->type == STT_FUNC || h->type == STT_GNU_IFUNC)
+          && ! SYMBOL_REFERENCES_LOCAL (info, h))
+        return bfd_reloc_dangerous;
     }
 
   is_sym_diff_reloc = FALSE;
   if (sym_diff_section != NULL)
     {
       BFD_ASSERT (sym_diff_section == input_section);
 
       switch (r_type)
         {
         case R_MN10300_32:
@@ skipping 176 matching lines @@
       value += addend;
 
       bfd_put_32 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_GNU_VTINHERIT:
     case R_MN10300_GNU_VTENTRY:
       return bfd_reloc_ok;
 
     case R_MN10300_GOTPC32:
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
       /* Use global offset table as symbol value.  */
-      value = bfd_get_section_by_name (dynobj,
-                                       ".got")->output_section->vma;
+      value = htab->root.sgot->output_section->vma;
       value -= (input_section->output_section->vma
                 + input_section->output_offset);
       value -= offset;
       value += addend;
 
       bfd_put_32 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_GOTPC16:
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
       /* Use global offset table as symbol value.  */
-      value = bfd_get_section_by_name (dynobj,
-                                       ".got")->output_section->vma;
+      value = htab->root.sgot->output_section->vma;
       value -= (input_section->output_section->vma
                 + input_section->output_offset);
       value -= offset;
       value += addend;
 
       if ((long) value > 0x7fff || (long) value < -0x8000)
         return bfd_reloc_overflow;
 
       bfd_put_16 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_GOTOFF32:
-      value -= bfd_get_section_by_name (dynobj,
-                                        ".got")->output_section->vma;
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
+      value -= htab->root.sgot->output_section->vma;
       value += addend;
 
       bfd_put_32 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_GOTOFF24:
-      value -= bfd_get_section_by_name (dynobj,
-                                        ".got")->output_section->vma;
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
+      value -= htab->root.sgot->output_section->vma;
       value += addend;
 
       if ((long) value > 0x7fffff || (long) value < -0x800000)
         return bfd_reloc_overflow;
 
       bfd_put_8 (input_bfd, value, hit_data);
       bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
       bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
       return bfd_reloc_ok;
 
     case R_MN10300_GOTOFF16:
-      value -= bfd_get_section_by_name (dynobj,
-                                        ".got")->output_section->vma;
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
+      value -= htab->root.sgot->output_section->vma;
       value += addend;
 
       if ((long) value > 0x7fff || (long) value < -0x8000)
         return bfd_reloc_overflow;
 
       bfd_put_16 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_PLT32:
       if (h != NULL
           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
           && h->plt.offset != (bfd_vma) -1)
         {
-          splt = bfd_get_section_by_name (dynobj, ".plt");
+          if (dynobj == NULL)
+            return bfd_reloc_dangerous;
 
+          splt = htab->root.splt;
           value = (splt->output_section->vma
                    + splt->output_offset
                    + h->plt.offset) - value;
         }
 
       value -= (input_section->output_section->vma
                 + input_section->output_offset);
       value -= offset;
       value += addend;
 
       bfd_put_32 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
     case R_MN10300_PLT16:
       if (h != NULL
           && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
           && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
           && h->plt.offset != (bfd_vma) -1)
         {
-          splt = bfd_get_section_by_name (dynobj, ".plt");
+          if (dynobj == NULL)
+            return bfd_reloc_dangerous;
 
+          splt = htab->root.splt;
           value = (splt->output_section->vma
                    + splt->output_offset
                    + h->plt.offset) - value;
         }
 
       value -= (input_section->output_section->vma
                 + input_section->output_offset);
       value -= offset;
       value += addend;
 
       if ((long) value > 0x7fff || (long) value < -0x8000)
         return bfd_reloc_overflow;
 
       bfd_put_16 (input_bfd, value, hit_data);
       return bfd_reloc_ok;
 
+    case R_MN10300_TLS_LDO:
+      value = dtpoff (info, value);
+      bfd_put_32 (input_bfd, value + addend, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_TLS_LE:
+      value = tpoff (info, value);
+      bfd_put_32 (input_bfd, value + addend, hit_data);
+      return bfd_reloc_ok;
+
+    case R_MN10300_TLS_LD:
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
+
+      sgot = htab->root.sgot;
+      BFD_ASSERT (sgot != NULL);
+      value = htab->tls_ldm_got.offset + sgot->output_offset;
+      bfd_put_32 (input_bfd, value, hit_data);
+
+      if (!htab->tls_ldm_got.rel_emitted)
+        {
+          asection * srelgot = bfd_get_linker_section (dynobj, ".rela.got");
+          Elf_Internal_Rela rel;
+
+          BFD_ASSERT (srelgot != NULL);
+          htab->tls_ldm_got.rel_emitted ++;
+          rel.r_offset = (sgot->output_section->vma
+                          + sgot->output_offset
+                          + htab->tls_ldm_got.offset);
+          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset);
+          bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset+4);
+          rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
+          rel.r_addend = 0;
+          bfd_elf32_swap_reloca_out (output_bfd, & rel,
+                                     (bfd_byte *) ((Elf32_External_Rela *) srelgot->contents
+                                                   + srelgot->reloc_count));
+          ++ srelgot->reloc_count;
+        }
+
+      return bfd_reloc_ok;
+
+    case R_MN10300_TLS_GOTIE:
+      value = tpoff (info, value);
+      /* Fall Through.  */
+
+    case R_MN10300_TLS_GD:
+    case R_MN10300_TLS_IE:
     case R_MN10300_GOT32:
     case R_MN10300_GOT24:
     case R_MN10300_GOT16:
-      {
-        sgot = bfd_get_section_by_name (dynobj, ".got");
+      if (dynobj == NULL)
+        return bfd_reloc_dangerous;
 
-          if (h != NULL)
-            {
-              bfd_vma off;
+      sgot = htab->root.sgot;
+      if (r_type == R_MN10300_TLS_GD)
+        value = dtpoff (info, value);
 
-              off = h->got.offset;
-              BFD_ASSERT (off != (bfd_vma) -1);
+      if (h != NULL)
+        {
+          bfd_vma off;
 
-              if (! elf_hash_table (info)->dynamic_sections_created
-                  || SYMBOL_REFERENCES_LOCAL (info, h))
-                /* This is actually a static link, or it is a
-                   -Bsymbolic link and the symbol is defined
-                   locally, or the symbol was forced to be local
-                   because of a version file.  We must initialize
-                   this entry in the global offset table.
+          off = h->got.offset;
+          /* Offsets in the GOT are allocated in check_relocs
+             which is not called for shared libraries... */
+          if (off == (bfd_vma) -1)
+            off = 0;
 
-                   When doing a dynamic link, we create a .rela.got
-                   relocation entry to initialize the value.  This
-                   is done in the finish_dynamic_symbol routine.  */
-                bfd_put_32 (output_bfd, value,
-                            sgot->contents + off);
+          if (sgot->contents != NULL
+              && (! elf_hash_table (info)->dynamic_sections_created
+                  || SYMBOL_REFERENCES_LOCAL (info, h)))
+            /* This is actually a static link, or it is a
+               -Bsymbolic link and the symbol is defined
+               locally, or the symbol was forced to be local
+               because of a version file.  We must initialize
+               this entry in the global offset table.
 
-              value = sgot->output_offset + off;
-            }
+               When doing a dynamic link, we create a .rela.got
+               relocation entry to initialize the value.  This
+               is done in the finish_dynamic_symbol routine.  */
+            bfd_put_32 (output_bfd, value,
+                        sgot->contents + off);
+
+          value = sgot->output_offset + off;
+        }
+      else
+        {
+          bfd_vma off;
+
+          off = elf_local_got_offsets (input_bfd)[symndx];
+
+          if (off & 1)
+            bfd_put_32 (output_bfd, value, sgot->contents + (off & ~ 1));
           else
             {
-              bfd_vma off;
-
-              off = elf_local_got_offsets (input_bfd)[symndx];
-
               bfd_put_32 (output_bfd, value, sgot->contents + off);
 
               if (info->shared)
                 {
                   asection * srelgot;
                   Elf_Internal_Rela outrel;
 
-                  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+                  srelgot = bfd_get_linker_section (dynobj, ".rela.got");
                   BFD_ASSERT (srelgot != NULL);
 
                   outrel.r_offset = (sgot->output_section->vma
                                      + sgot->output_offset
                                      + off);
-                  outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
+                  switch (r_type)
+                    {
+                    case R_MN10300_TLS_GD:
+                      outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPOFF);
+                      outrel.r_offset = (sgot->output_section->vma
+                                         + sgot->output_offset
+                                         + off + 4);
+                      bfd_elf32_swap_reloca_out (output_bfd, & outrel,
+                                                 (bfd_byte *) (((Elf32_External_Rela *)
+                                                                srelgot->contents)
+                                                               + srelgot->reloc_count));
+                      ++ srelgot->reloc_count;
+                      outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
+                      break;
+                    case R_MN10300_TLS_GOTIE:
+                    case R_MN10300_TLS_IE:
+                      outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
+                      break;
+                    default:
+                      outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
+                      break;
+                    }
+
                   outrel.r_addend = value;
                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,
                                              (bfd_byte *) (((Elf32_External_Rela *)
                                                             srelgot->contents)
                                                            + srelgot->reloc_count));
                   ++ srelgot->reloc_count;
+                  elf_local_got_offsets (input_bfd)[symndx] |= 1;
                 }
 
-              value = sgot->output_offset + off;
+              value = sgot->output_offset + (off & ~(bfd_vma) 1);
             }
-      }
+        }
 
       value += addend;
 
-      if (r_type == R_MN10300_GOT32)
+      if (r_type == R_MN10300_TLS_IE)
+        {
+          value += sgot->output_section->vma;
+          bfd_put_32 (input_bfd, value, hit_data);
+          return bfd_reloc_ok;
+        }
+      else if (r_type == R_MN10300_TLS_GOTIE
+               || r_type == R_MN10300_TLS_GD
+               || r_type == R_MN10300_TLS_LD)
         {
           bfd_put_32 (input_bfd, value, hit_data);
           return bfd_reloc_ok;
+        }
+      else if (r_type == R_MN10300_GOT32)
+        {
+          bfd_put_32 (input_bfd, value, hit_data);
+          return bfd_reloc_ok;
         }
       else if (r_type == R_MN10300_GOT24)
         {
           if ((long) value > 0x7fffff || (long) value < -0x800000)
             return bfd_reloc_overflow;
 
           bfd_put_8 (input_bfd, value & 0xff, hit_data);
           bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
           bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
           return bfd_reloc_ok;
@@ skipping 18 matching lines @@
 
 static bfd_boolean
 mn10300_elf_relocate_section (bfd *output_bfd,
                               struct bfd_link_info *info,
                               bfd *input_bfd,
                               asection *input_section,
                               bfd_byte *contents,
                               Elf_Internal_Rela *relocs,
                               Elf_Internal_Sym *local_syms,
                               asection **local_sections)