← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to bfd/elf32-i386.c

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bfd/elf32-i386.c
1
1
/* Intel 80386/80486-specific support for 32-bit ELF
2
2
   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3
 
   2003, 2004, 2005, 2006 Free Software Foundation, Inc.
 
3
   2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4
4
 
5
5
   This file is part of BFD, the Binary File Descriptor library.
6
6
 
7
7
   This program is free software; you can redistribute it and/or modify
8
8
   it under the terms of the GNU General Public License as published by
9
 
   the Free Software Foundation; either version 2 of the License, or
 
9
   the Free Software Foundation; either version 3 of the License, or
10
10
   (at your option) any later version.
11
11
 
12
12
   This program is distributed in the hope that it will be useful,
16
16
 
17
17
   You should have received a copy of the GNU General Public License
18
18
   along with this program; if not, write to the Free Software
19
 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
 
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 
20
   MA 02110-1301, USA.  */
20
21
 
 
22
#include "sysdep.h"
21
23
#include "bfd.h"
22
 
#include "sysdep.h"
23
24
#include "bfdlink.h"
24
25
#include "libbfd.h"
25
26
#include "elf-bfd.h"
26
27
#include "elf-vxworks.h"
 
28
#include "bfd_stdint.h"
27
29
 
28
30
/* 386 uses REL relocations instead of RELA.  */
29
31
#define USE_REL 1
330
332
  return 0;
331
333
}
332
334
 
333
 
static void
334
 
elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
335
 
                            arelent *cache_ptr,
336
 
                            Elf_Internal_Rela *dst)
337
 
{
338
 
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 
335
static reloc_howto_type *
 
336
elf_i386_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 
337
                            const char *r_name)
 
338
{
 
339
  unsigned int i;
 
340
 
 
341
  for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 
342
    if (elf_howto_table[i].name != NULL
 
343
        && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 
344
      return &elf_howto_table[i];
 
345
 
 
346
  return NULL;
 
347
}
 
348
 
 
349
static reloc_howto_type *
 
350
elf_i386_rtype_to_howto (bfd *abfd, unsigned r_type)
 
351
{
339
352
  unsigned int indx;
340
353
 
341
354
  if ((indx = r_type) >= R_386_standard
350
363
                             abfd, (int) r_type);
351
364
      indx = R_386_NONE;
352
365
    }
353
 
  cache_ptr->howto = &elf_howto_table[indx];
 
366
  BFD_ASSERT (elf_howto_table [indx].type == r_type);
 
367
  return &elf_howto_table[indx];
 
368
}
 
369
 
 
370
static void
 
371
elf_i386_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
 
372
                            arelent *cache_ptr,
 
373
                            Elf_Internal_Rela *dst)
 
374
{
 
375
  unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 
376
  cache_ptr->howto = elf_i386_rtype_to_howto (abfd, r_type);
354
377
}
355
378
 
356
379
/* Return whether a symbol name implies a local label.  The UnixWare
878
901
    _bfd_elf_link_hash_copy_indirect (info, dir, ind);
879
902
}
880
903
 
881
 
static int
882
 
elf_i386_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 
904
typedef union 
 
905
  {
 
906
    unsigned char c[2];
 
907
    uint16_t i;
 
908
  }
 
909
i386_opcode16;
 
910
 
 
911
/* Return TRUE if the TLS access code sequence support transition
 
912
   from R_TYPE.  */
 
913
 
 
914
static bfd_boolean
 
915
elf_i386_check_tls_transition (bfd *abfd, asection *sec,
 
916
                               bfd_byte *contents,
 
917
                               Elf_Internal_Shdr *symtab_hdr,
 
918
                               struct elf_link_hash_entry **sym_hashes,
 
919
                               unsigned int r_type,
 
920
                               const Elf_Internal_Rela *rel,
 
921
                               const Elf_Internal_Rela *relend)
883
922
{
884
 
  if (info->shared)
885
 
    return r_type;
886
 
 
 
923
  unsigned int val, type;
 
924
  unsigned long r_symndx;
 
925
  struct elf_link_hash_entry *h;
 
926
  bfd_vma offset;
 
927
 
 
928
  /* Get the section contents.  */
 
929
  if (contents == NULL)
 
930
    {
 
931
      if (elf_section_data (sec)->this_hdr.contents != NULL)
 
932
        contents = elf_section_data (sec)->this_hdr.contents;
 
933
      else
 
934
        {
 
935
          /* FIXME: How to better handle error condition?  */
 
936
          if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 
937
            return FALSE;
 
938
 
 
939
          /* Cache the section contents for elf_link_input_bfd.  */
 
940
          elf_section_data (sec)->this_hdr.contents = contents;
 
941
        }
 
942
    }
 
943
 
 
944
  offset = rel->r_offset;
887
945
  switch (r_type)
888
946
    {
889
947
    case R_386_TLS_GD:
890
 
    case R_386_TLS_GOTDESC:
891
 
    case R_386_TLS_DESC_CALL:
892
 
    case R_386_TLS_IE_32:
893
 
      if (is_local)
894
 
        return R_386_TLS_LE_32;
895
 
      return R_386_TLS_IE_32;
896
 
    case R_386_TLS_IE:
897
 
    case R_386_TLS_GOTIE:
898
 
      if (is_local)
899
 
        return R_386_TLS_LE_32;
900
 
      return r_type;
901
 
    case R_386_TLS_LDM:
902
 
      return R_386_TLS_LE_32;
903
 
    }
904
 
 
905
 
  return r_type;
 
948
    case R_386_TLS_LDM:
 
949
      if (offset < 2 || (rel + 1) >= relend)
 
950
        return FALSE;
 
951
 
 
952
      type = bfd_get_8 (abfd, contents + offset - 2);
 
953
      if (r_type == R_386_TLS_GD)
 
954
        {
 
955
          /* Check transition from LD access model.  Only
 
956
                leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr
 
957
                leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop
 
958
             can transit to different access model.  */
 
959
          if ((offset + 10) > sec->size ||
 
960
              (type != 0x8d && type != 0x04))
 
961
            return FALSE;
 
962
 
 
963
          val = bfd_get_8 (abfd, contents + offset - 1);
 
964
          if (type == 0x04)
 
965
            {
 
966
              /* leal foo@tlsgd(,%reg,1), %eax; call ___tls_get_addr */
 
967
              if (offset < 3)
 
968
                return FALSE;
 
969
 
 
970
              if (bfd_get_8 (abfd, contents + offset - 3) != 0x8d)
 
971
                return FALSE;
 
972
 
 
973
              if ((val & 0xc7) != 0x05 || val == (4 << 3))
 
974
                return FALSE;
 
975
            }
 
976
          else
 
977
            {
 
978
              /* leal foo@tlsgd(%reg), %eax; call ___tls_get_addr; nop  */
 
979
              if ((val & 0xf8) != 0x80 || (val & 7) == 4)
 
980
                return FALSE;
 
981
 
 
982
              if (bfd_get_8 (abfd, contents + offset + 9) != 0x90)
 
983
                return FALSE;
 
984
            }
 
985
        }
 
986
      else
 
987
        {
 
988
          /* Check transition from LD access model.  Only
 
989
                leal foo@tlsgd(%reg), %eax; call ___tls_get_addr
 
990
             can transit to different access model.  */
 
991
          if (type != 0x8d || (offset + 9) > sec->size)
 
992
            return FALSE;
 
993
 
 
994
          val = bfd_get_8 (abfd, contents + offset - 1);
 
995
          if ((val & 0xf8) != 0x80 || (val & 7) == 4)
 
996
            return FALSE;
 
997
        }
 
998
 
 
999
      if (bfd_get_8 (abfd, contents + offset + 4) != 0xe8)
 
1000
        return FALSE;
 
1001
 
 
1002
      r_symndx = ELF32_R_SYM (rel[1].r_info);
 
1003
      if (r_symndx < symtab_hdr->sh_info)
 
1004
        return FALSE;
 
1005
 
 
1006
      h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 
1007
      return (h != NULL
 
1008
              && h->root.root.string != NULL
 
1009
              && (ELF32_R_TYPE (rel[1].r_info) == R_386_PC32
 
1010
                  || ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32)
 
1011
              && (strcmp (h->root.root.string, "___tls_get_addr") == 0));
 
1012
 
 
1013
    case R_386_TLS_IE:
 
1014
      /* Check transition from IE access model:
 
1015
                movl foo@indntpoff(%rip), %eax
 
1016
                movl foo@indntpoff(%rip), %reg
 
1017
                addl foo@indntpoff(%rip), %reg
 
1018
       */
 
1019
 
 
1020
      if (offset < 1 || (offset + 4) > sec->size)
 
1021
        return FALSE;
 
1022
 
 
1023
      /* Check "movl foo@tpoff(%rip), %eax" first.  */
 
1024
      val = bfd_get_8 (abfd, contents + offset - 1);
 
1025
      if (val == 0xa1)
 
1026
        return TRUE;
 
1027
 
 
1028
      if (offset < 2)
 
1029
        return FALSE;
 
1030
 
 
1031
      /* Check movl|addl foo@tpoff(%rip), %reg.   */
 
1032
      type = bfd_get_8 (abfd, contents + offset - 2);
 
1033
      return ((type == 0x8b || type == 0x03)
 
1034
              && (val & 0xc7) == 0x05);
 
1035
 
 
1036
    case R_386_TLS_GOTIE:
 
1037
    case R_386_TLS_IE_32:
 
1038
      /* Check transition from {IE_32,GOTIE} access model:
 
1039
                subl foo@{tpoff,gontoff}(%reg1), %reg2
 
1040
                movl foo@{tpoff,gontoff}(%reg1), %reg2
 
1041
                addl foo@{tpoff,gontoff}(%reg1), %reg2
 
1042
       */
 
1043
 
 
1044
      if (offset < 2 || (offset + 4) > sec->size)
 
1045
        return FALSE;
 
1046
 
 
1047
      val = bfd_get_8 (abfd, contents + offset - 1);
 
1048
      if ((val & 0xc0) != 0x80 || (val & 7) == 4)
 
1049
        return FALSE;
 
1050
 
 
1051
      type = bfd_get_8 (abfd, contents + offset - 2);
 
1052
      return type == 0x8b || type == 0x2b || type == 0x03;
 
1053
 
 
1054
    case R_386_TLS_GOTDESC:
 
1055
      /* Check transition from GDesc access model:
 
1056
                leal x@tlsdesc(%ebx), %eax
 
1057
 
 
1058
         Make sure it's a leal adding ebx to a 32-bit offset
 
1059
         into any register, although it's probably almost always
 
1060
         going to be eax.  */
 
1061
 
 
1062
      if (offset < 2 || (offset + 4) > sec->size)
 
1063
        return FALSE;
 
1064
 
 
1065
      if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
 
1066
        return FALSE;
 
1067
 
 
1068
      val = bfd_get_8 (abfd, contents + offset - 1);
 
1069
      return (val & 0xc7) == 0x83;
 
1070
 
 
1071
    case R_386_TLS_DESC_CALL:
 
1072
      /* Check transition from GDesc access model:
 
1073
                call *x@tlsdesc(%rax)
 
1074
       */
 
1075
      if (offset + 2 <= sec->size)
 
1076
        {
 
1077
          /* Make sure that it's a call *x@tlsdesc(%rax).  */
 
1078
          static i386_opcode16 call = { { 0xff, 0x10 } };
 
1079
          return bfd_get_16 (abfd, contents + offset) == call.i;
 
1080
        }
 
1081
 
 
1082
      return FALSE;
 
1083
 
 
1084
    default:
 
1085
      abort ();
 
1086
    }
 
1087
}
 
1088
 
 
1089
/* Return TRUE if the TLS access transition is OK or no transition
 
1090
   will be performed.  Update R_TYPE if there is a transition.  */
 
1091
 
 
1092
static bfd_boolean
 
1093
elf_i386_tls_transition (struct bfd_link_info *info, bfd *abfd,
 
1094
                         asection *sec, bfd_byte *contents,
 
1095
                         Elf_Internal_Shdr *symtab_hdr,
 
1096
                         struct elf_link_hash_entry **sym_hashes,
 
1097
                         unsigned int *r_type, int tls_type,
 
1098
                         const Elf_Internal_Rela *rel,
 
1099
                         const Elf_Internal_Rela *relend,
 
1100
                         struct elf_link_hash_entry *h)
 
1101
{
 
1102
  unsigned int from_type = *r_type;
 
1103
  unsigned int to_type = from_type;
 
1104
  bfd_boolean check = TRUE;
 
1105
 
 
1106
  switch (from_type)
 
1107
    {
 
1108
    case R_386_TLS_GD:
 
1109
    case R_386_TLS_GOTDESC:
 
1110
    case R_386_TLS_DESC_CALL:
 
1111
    case R_386_TLS_IE_32:
 
1112
    case R_386_TLS_IE:
 
1113
    case R_386_TLS_GOTIE:
 
1114
      if (!info->shared)
 
1115
        {
 
1116
          if (h == NULL)
 
1117
            to_type = R_386_TLS_LE_32;
 
1118
          else if (from_type != R_386_TLS_IE
 
1119
                   && from_type != R_386_TLS_GOTIE)
 
1120
            to_type = R_386_TLS_IE_32;
 
1121
        }
 
1122
 
 
1123
      /* When we are called from elf_i386_relocate_section, CONTENTS
 
1124
         isn't NULL and there may be additional transitions based on
 
1125
         TLS_TYPE.  */
 
1126
      if (contents != NULL)
 
1127
        {
 
1128
          unsigned int new_to_type = to_type;
 
1129
 
 
1130
          if (!info->shared
 
1131
              && h != NULL
 
1132
              && h->dynindx == -1
 
1133
              && (tls_type & GOT_TLS_IE))
 
1134
            new_to_type = R_386_TLS_LE_32;
 
1135
 
 
1136
          if (to_type == R_386_TLS_GD
 
1137
              || to_type == R_386_TLS_GOTDESC
 
1138
              || to_type == R_386_TLS_DESC_CALL)
 
1139
            {
 
1140
              if (tls_type == GOT_TLS_IE_POS)
 
1141
                new_to_type = R_386_TLS_GOTIE;
 
1142
              else if (tls_type & GOT_TLS_IE)
 
1143
                new_to_type = R_386_TLS_IE_32;
 
1144
            }
 
1145
 
 
1146
          /* We checked the transition before when we were called from
 
1147
             elf_i386_check_relocs.  We only want to check the new
 
1148
             transition which hasn't been checked before.  */
 
1149
          check = new_to_type != to_type && from_type == to_type;
 
1150
          to_type = new_to_type;
 
1151
        }
 
1152
 
 
1153
      break;
 
1154
 
 
1155
    case R_386_TLS_LDM:
 
1156
      if (!info->shared)
 
1157
        to_type = R_386_TLS_LE_32;
 
1158
      break;
 
1159
 
 
1160
    default:
 
1161
      return TRUE;
 
1162
    }
 
1163
 
 
1164
  /* Return TRUE if there is no transition.  */
 
1165
  if (from_type == to_type)
 
1166
    return TRUE;
 
1167
 
 
1168
  /* Check if the transition can be performed.  */
 
1169
  if (check
 
1170
      && ! elf_i386_check_tls_transition (abfd, sec, contents,
 
1171
                                          symtab_hdr, sym_hashes,
 
1172
                                          from_type, rel, relend))
 
1173
    {
 
1174
      const reloc_howto_type *from, *to;
 
1175
 
 
1176
      from = elf_i386_rtype_to_howto (abfd, from_type);
 
1177
      to = elf_i386_rtype_to_howto (abfd, to_type);
 
1178
 
 
1179
      (*_bfd_error_handler)
 
1180
        (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
 
1181
           "in section `%A' failed"),
 
1182
         abfd, sec, from->name, to->name,
 
1183
         h ? h->root.root.string : "a local symbol",
 
1184
         (unsigned long) rel->r_offset);
 
1185
      bfd_set_error (bfd_error_bad_value);
 
1186
      return FALSE;
 
1187
    }
 
1188
 
 
1189
  *r_type = to_type;
 
1190
  return TRUE;
906
1191
}
907
1192
 
908
1193
/* Look through the relocs for a section during the first phase, and
959
1244
            h = (struct elf_link_hash_entry *) h->root.u.i.link;
960
1245
        }
961
1246
 
962
 
      r_type = elf_i386_tls_transition (info, r_type, h == NULL);
 
1247
      if (! elf_i386_tls_transition (info, abfd, sec, NULL,
 
1248
                                     symtab_hdr, sym_hashes,
 
1249
                                     &r_type, GOT_UNKNOWN,
 
1250
                                     rel, rel_end, h)) 
 
1251
        return FALSE;
963
1252
 
964
1253
      switch (r_type)
965
1254
        {
1255
1544
          /* This relocation describes the C++ object vtable hierarchy.
1256
1545
             Reconstruct it for later use during GC.  */
1257
1546
        case R_386_GNU_VTINHERIT:
1258
 
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 
1547
          BFD_ASSERT (h != NULL);
 
1548
          if (h != NULL
 
1549
              && !bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1259
1550
            return FALSE;
1260
1551
          break;
1261
1552
 
1262
1553
          /* This relocation describes which C++ vtable entries are actually
1263
1554
             used.  Record for later use during GC.  */
1264
1555
        case R_386_GNU_VTENTRY:
1265
 
          if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
 
1556
          BFD_ASSERT (h != NULL);
 
1557
          if (h != NULL
 
1558
              && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
1266
1559
            return FALSE;
1267
1560
          break;
1268
1561
 
1344
1637
        }
1345
1638
 
1346
1639
      r_type = ELF32_R_TYPE (rel->r_info);
1347
 
      r_type = elf_i386_tls_transition (info, r_type, h != NULL);
 
1640
      if (! elf_i386_tls_transition (info, abfd, sec, NULL,
 
1641
                                     symtab_hdr, sym_hashes,
 
1642
                                     &r_type, GOT_UNKNOWN,
 
1643
                                     rel, relend, h)) 
 
1644
        return FALSE;
 
1645
 
1348
1646
      switch (r_type)
1349
1647
        {
1350
1648
        case R_386_TLS_LDM:
1405
1703
{
1406
1704
  struct elf_i386_link_hash_table *htab;
1407
1705
  asection *s;
1408
 
  unsigned int power_of_two;
1409
1706
 
1410
1707
  /* If this is a function, put it in the procedure linkage table.  We
1411
1708
     will fill in the contents of the procedure linkage table later,
1525
1822
      h->needs_copy = 1;
1526
1823
    }
1527
1824
 
1528
 
  /* We need to figure out the alignment required for this symbol.  I
1529
 
     have no idea how ELF linkers handle this.  */
1530
 
  power_of_two = bfd_log2 (h->size);
1531
 
  if (power_of_two > 3)
1532
 
    power_of_two = 3;
1533
 
 
1534
 
  /* Apply the required alignment.  */
1535
1825
  s = htab->sdynbss;
1536
 
  s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1537
 
  if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1538
 
    {
1539
 
      if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1540
 
        return FALSE;
1541
 
    }
1542
 
 
1543
 
  /* Define the symbol as being at this point in the section.  */
1544
 
  h->root.u.def.section = s;
1545
 
  h->root.u.def.value = s->size;
1546
 
 
1547
 
  /* Increment the section size to make room for the symbol.  */
1548
 
  s->size += h->size;
1549
 
 
1550
 
  return TRUE;
 
1826
 
 
1827
  return _bfd_elf_adjust_dynamic_copy (h, s);
1551
1828
}
1552
1829
 
1553
1830
/* Allocate space in .plt, .got and associated reloc sections for
2264
2541
      howto = elf_howto_table + indx;
2265
2542
 
2266
2543
      r_symndx = ELF32_R_SYM (rel->r_info);
2267
 
 
2268
 
      if (info->relocatable)
2269
 
        {
2270
 
          bfd_vma val;
2271
 
          bfd_byte *where;
2272
 
 
2273
 
          /* This is a relocatable link.  We don't have to change
2274
 
             anything, unless the reloc is against a section symbol,
2275
 
             in which case we have to adjust according to where the
2276
 
             section symbol winds up in the output section.  */
2277
 
          if (r_symndx >= symtab_hdr->sh_info)
2278
 
            continue;
2279
 
 
2280
 
          sym = local_syms + r_symndx;
2281
 
          if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2282
 
            continue;
2283
 
 
2284
 
          sec = local_sections[r_symndx];
2285
 
          val = sec->output_offset;
2286
 
          if (val == 0)
2287
 
            continue;
2288
 
 
2289
 
          where = contents + rel->r_offset;
2290
 
          switch (howto->size)
2291
 
            {
2292
 
              /* FIXME: overflow checks.  */
2293
 
            case 0:
2294
 
              val += bfd_get_8 (input_bfd, where);
2295
 
              bfd_put_8 (input_bfd, val, where);
2296
 
              break;
2297
 
            case 1:
2298
 
              val += bfd_get_16 (input_bfd, where);
2299
 
              bfd_put_16 (input_bfd, val, where);
2300
 
              break;
2301
 
            case 2:
2302
 
              val += bfd_get_32 (input_bfd, where);
2303
 
              bfd_put_32 (input_bfd, val, where);
2304
 
              break;
2305
 
            default:
2306
 
              abort ();
2307
 
            }
2308
 
          continue;
2309
 
        }
2310
 
 
2311
 
      /* This is a final link.  */
2312
2544
      h = NULL;
2313
2545
      sym = NULL;
2314
2546
      sec = NULL;
2320
2552
          relocation = (sec->output_section->vma
2321
2553
                        + sec->output_offset
2322
2554
                        + sym->st_value);
2323
 
          if ((sec->flags & SEC_MERGE)
2324
 
              && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 
2555
 
 
2556
          if (ELF_ST_TYPE (sym->st_info) == STT_SECTION
 
2557
              && ((sec->flags & SEC_MERGE) != 0
 
2558
                  || (info->relocatable
 
2559
                      && sec->output_offset != 0)))
2325
2560
            {
2326
 
              asection *msec;
2327
2561
              bfd_vma addend;
2328
2562
              bfd_byte *where = contents + rel->r_offset;
2329
2563
 
2357
2591
                  abort ();
2358
2592
                }
2359
2593
 
2360
 
              msec = sec;
2361
 
              addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2362
 
              addend -= relocation;
2363
 
              addend += msec->output_section->vma + msec->output_offset;
 
2594
              if (info->relocatable)
 
2595
                addend += sec->output_offset;
 
2596
              else
 
2597
                {
 
2598
                  asection *msec = sec;
 
2599
                  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec,
 
2600
                                                   addend);
 
2601
                  addend -= relocation;
 
2602
                  addend += msec->output_section->vma + msec->output_offset;
 
2603
                }
2364
2604
 
2365
2605
              switch (howto->size)
2366
2606
                {
2393
2633
                                   unresolved_reloc, warned);
2394
2634
        }
2395
2635
 
2396
 
      if (r_symndx == 0)
 
2636
      if (sec != NULL && elf_discarded_section (sec))
2397
2637
        {
2398
 
          /* r_symndx will be zero only for relocs against symbols from
2399
 
             removed linkonce sections, or sections discarded by a linker
2400
 
             script.  For these relocs, we just want the section contents
2401
 
             zeroed.  Avoid any special processing.  */
 
2638
          /* For relocs against symbols from removed linkonce sections,
 
2639
             or sections discarded by a linker script, we just want the
 
2640
             section contents zeroed.  Avoid any special processing.  */
2402
2641
          _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
 
2642
          rel->r_info = 0;
 
2643
          rel->r_addend = 0;
2403
2644
          continue;
2404
2645
        }
2405
2646
 
 
2647
      if (info->relocatable)
 
2648
        continue;
 
2649
 
2406
2650
      switch (r_type)
2407
2651
        {
2408
2652
        case R_386_GOT32:
2658
2902
        case R_386_TLS_DESC_CALL:
2659
2903
        case R_386_TLS_IE_32:
2660
2904
        case R_386_TLS_GOTIE:
2661
 
          r_type = elf_i386_tls_transition (info, r_type, h == NULL);
2662
2905
          tls_type = GOT_UNKNOWN;
2663
2906
          if (h == NULL && local_got_offsets)
2664
2907
            tls_type = elf_i386_local_got_tls_type (input_bfd) [r_symndx];
2665
2908
          else if (h != NULL)
2666
 
            {
2667
 
              tls_type = elf_i386_hash_entry(h)->tls_type;
2668
 
              if (!info->shared && h->dynindx == -1 && (tls_type & GOT_TLS_IE))
2669
 
                r_type = R_386_TLS_LE_32;
2670
 
            }
 
2909
            tls_type = elf_i386_hash_entry(h)->tls_type;
2671
2910
          if (tls_type == GOT_TLS_IE)
2672
2911
            tls_type = GOT_TLS_IE_NEG;
2673
 
          if (r_type == R_386_TLS_GD
2674
 
              || r_type == R_386_TLS_GOTDESC
2675
 
              || r_type == R_386_TLS_DESC_CALL)
2676
 
            {
2677
 
              if (tls_type == GOT_TLS_IE_POS)
2678
 
                r_type = R_386_TLS_GOTIE;
2679
 
              else if (tls_type & GOT_TLS_IE)
2680
 
                r_type = R_386_TLS_IE_32;
2681
 
            }
 
2912
 
 
2913
          if (! elf_i386_tls_transition (info, input_bfd,
 
2914
                                         input_section, contents,
 
2915
                                         symtab_hdr, sym_hashes,
 
2916
                                         &r_type, tls_type, rel,
 
2917
                                         relend, h))
 
2918
            return FALSE;
2682
2919
 
2683
2920
          if (r_type == R_386_TLS_LE_32)
2684
2921
            {
2685
2922
              BFD_ASSERT (! unresolved_reloc);
2686
2923
              if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_GD)
2687
2924
                {
2688
 
                  unsigned int val, type;
 
2925
                  unsigned int type;
2689
2926
                  bfd_vma roff;
2690
2927
 
2691
2928
                  /* GD->LE transition.  */
2692
 
                  BFD_ASSERT (rel->r_offset >= 2);
2693
2929
                  type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2694
 
                  BFD_ASSERT (type == 0x8d || type == 0x04);
2695
 
                  BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2696
 
                  BFD_ASSERT (bfd_get_8 (input_bfd,
2697
 
                                         contents + rel->r_offset + 4)
2698
 
                              == 0xe8);
2699
 
                  BFD_ASSERT (rel + 1 < relend);
2700
 
                  BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
2701
 
                  roff = rel->r_offset + 5;
2702
 
                  val = bfd_get_8 (input_bfd,
2703
 
                                   contents + rel->r_offset - 1);
2704
2930
                  if (type == 0x04)
2705
2931
                    {
2706
2932
                      /* leal foo(,%reg,1), %eax; call ___tls_get_addr
2707
2933
                         Change it into:
2708
2934
                         movl %gs:0, %eax; subl $foo@tpoff, %eax
2709
2935
                         (6 byte form of subl).  */
2710
 
                      BFD_ASSERT (rel->r_offset >= 3);
2711
 
                      BFD_ASSERT (bfd_get_8 (input_bfd,
2712
 
                                             contents + rel->r_offset - 3)
2713
 
                                  == 0x8d);
2714
 
                      BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
2715
2936
                      memcpy (contents + rel->r_offset - 3,
2716
2937
                              "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
 
2938
                      roff = rel->r_offset + 5;
2717
2939
                    }
2718
2940
                  else
2719
2941
                    {
2720
 
                      BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
2721
 
                      if (rel->r_offset + 10 <= input_section->size
2722
 
                          && bfd_get_8 (input_bfd,
2723
 
                                        contents + rel->r_offset + 9) == 0x90)
2724
 
                        {
2725
 
                          /* leal foo(%reg), %eax; call ___tls_get_addr; nop
2726
 
                             Change it into:
2727
 
                             movl %gs:0, %eax; subl $foo@tpoff, %eax
2728
 
                             (6 byte form of subl).  */
2729
 
                          memcpy (contents + rel->r_offset - 2,
2730
 
                                  "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2731
 
                          roff = rel->r_offset + 6;
2732
 
                        }
2733
 
                      else
2734
 
                        {
2735
 
                          /* leal foo(%reg), %eax; call ___tls_get_addr
2736
 
                             Change it into:
2737
 
                             movl %gs:0, %eax; subl $foo@tpoff, %eax
2738
 
                             (5 byte form of subl).  */
2739
 
                          memcpy (contents + rel->r_offset - 2,
2740
 
                                  "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2741
 
                        }
 
2942
                      /* leal foo(%reg), %eax; call ___tls_get_addr; nop
 
2943
                         Change it into:
 
2944
                         movl %gs:0, %eax; subl $foo@tpoff, %eax
 
2945
                         (6 byte form of subl).  */
 
2946
                      memcpy (contents + rel->r_offset - 2,
 
2947
                              "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
 
2948
                      roff = rel->r_offset + 6;
2742
2949
                    }
2743
2950
                  bfd_put_32 (output_bfd, tpoff (info, relocation),
2744
2951
                              contents + roff);
2745
 
                  /* Skip R_386_PLT32.  */
 
2952
                  /* Skip R_386_PC32/R_386_PLT32.  */
2746
2953
                  rel++;
2747
2954
                  continue;
2748
2955
                }
2756
2963
 
2757
2964
                     Registers other than %eax may be set up here.  */
2758
2965
 
2759
 
                  unsigned int val, type;
 
2966
                  unsigned int val;
2760
2967
                  bfd_vma roff;
2761
2968
 
2762
 
                  /* First, make sure it's a leal adding ebx to a
2763
 
                     32-bit offset into any register, although it's
2764
 
                     probably almost always going to be eax.  */
2765
2969
                  roff = rel->r_offset;
2766
 
                  BFD_ASSERT (roff >= 2);
2767
 
                  type = bfd_get_8 (input_bfd, contents + roff - 2);
2768
 
                  BFD_ASSERT (type == 0x8d);
2769
2970
                  val = bfd_get_8 (input_bfd, contents + roff - 1);
2770
 
                  BFD_ASSERT ((val & 0xc7) == 0x83);
2771
 
                  BFD_ASSERT (roff + 4 <= input_section->size);
2772
2971
 
2773
2972
                  /* Now modify the instruction as appropriate.  */
2774
2973
                  /* aoliva FIXME: remove the above and xor the byte
2785
2984
                     It's originally:
2786
2985
                     call *(%eax)
2787
2986
                     Turn it into:
2788
 
                     nop; nop  */
 
2987
                     xchg %ax,%ax  */
2789
2988
 
2790
 
                  unsigned int val, type;
2791
2989
                  bfd_vma roff;
2792
 
 
2793
 
                  /* First, make sure it's a call *(%eax).  */
 
2990
                  
2794
2991
                  roff = rel->r_offset;
2795
 
                  BFD_ASSERT (roff + 2 <= input_section->size);
2796
 
                  type = bfd_get_8 (input_bfd, contents + roff);
2797
 
                  BFD_ASSERT (type == 0xff);
2798
 
                  val = bfd_get_8 (input_bfd, contents + roff + 1);
2799
 
                  BFD_ASSERT (val == 0x10);
2800
 
 
2801
 
                  /* Now modify the instruction as appropriate.  Use
2802
 
                     xchg %ax,%ax instead of 2 nops.  */
2803
2992
                  bfd_put_8 (output_bfd, 0x66, contents + roff);
2804
2993
                  bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2805
2994
                  continue;
2806
2995
                }
2807
2996
              else if (ELF32_R_TYPE (rel->r_info) == R_386_TLS_IE)
2808
2997
                {
2809
 
                  unsigned int val, type;
 
2998
                  unsigned int val;
2810
2999
 
2811
3000
                  /* IE->LE transition:
2812
3001
                     Originally it can be one of:
2817
3006
                     movl $foo, %eax
2818
3007
                     movl $foo, %reg
2819
3008
                     addl $foo, %reg.  */
2820
 
                  BFD_ASSERT (rel->r_offset >= 1);
2821
3009
                  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2822
 
                  BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2823
3010
                  if (val == 0xa1)
2824
3011
                    {
2825
3012
                      /* movl foo, %eax.  */
2828
3015
                    }
2829
3016
                  else
2830
3017
                    {
2831
 
                      BFD_ASSERT (rel->r_offset >= 2);
 
3018
                      unsigned int type;
 
3019
 
2832
3020
                      type = bfd_get_8 (input_bfd,
2833
3021
                                        contents + rel->r_offset - 2);
2834
3022
                      switch (type)
2835
3023
                        {
2836
3024
                        case 0x8b:
2837
3025
                          /* movl */
2838
 
                          BFD_ASSERT ((val & 0xc7) == 0x05);
2839
3026
                          bfd_put_8 (output_bfd, 0xc7,
2840
3027
                                     contents + rel->r_offset - 2);
2841
3028
                          bfd_put_8 (output_bfd,
2844
3031
                          break;
2845
3032
                        case 0x03:
2846
3033
                          /* addl */
2847
 
                          BFD_ASSERT ((val & 0xc7) == 0x05);
2848
3034
                          bfd_put_8 (output_bfd, 0x81,
2849
3035
                                     contents + rel->r_offset - 2);
2850
3036
                          bfd_put_8 (output_bfd,
2873
3059
                     subl $foo, %reg2
2874
3060
                     movl $foo, %reg2 (6 byte form)
2875
3061
                     addl $foo, %reg2.  */
2876
 
                  BFD_ASSERT (rel->r_offset >= 2);
2877
3062
                  type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2878
3063
                  val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2879
 
                  BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2880
 
                  BFD_ASSERT ((val & 0xc0) == 0x80 && (val & 7) != 4);
2881
3064
                  if (type == 0x8b)
2882
3065
                    {
2883
3066
                      /* movl */
3078
3261
              bfd_vma roff;
3079
3262
 
3080
3263
              /* GD->IE transition.  */
3081
 
              BFD_ASSERT (rel->r_offset >= 2);
3082
3264
              type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
3083
 
              BFD_ASSERT (type == 0x8d || type == 0x04);
3084
 
              BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3085
 
              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3086
 
                          == 0xe8);
3087
 
              BFD_ASSERT (rel + 1 < relend);
3088
 
              BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
3089
 
              roff = rel->r_offset - 3;
3090
3265
              val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3091
3266
              if (type == 0x04)
3092
3267
                {
3093
3268
                  /* leal foo(,%reg,1), %eax; call ___tls_get_addr
3094
3269
                     Change it into:
3095
3270
                     movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3096
 
                  BFD_ASSERT (rel->r_offset >= 3);
3097
 
                  BFD_ASSERT (bfd_get_8 (input_bfd,
3098
 
                                         contents + rel->r_offset - 3)
3099
 
                              == 0x8d);
3100
 
                  BFD_ASSERT ((val & 0xc7) == 0x05 && val != (4 << 3));
3101
3271
                  val >>= 3;
 
3272
                  roff = rel->r_offset - 3;
3102
3273
                }
3103
3274
              else
3104
3275
                {
3105
3276
                  /* leal foo(%reg), %eax; call ___tls_get_addr; nop
3106
3277
                     Change it into:
3107
3278
                     movl %gs:0, %eax; subl $foo@gottpoff(%reg), %eax.  */
3108
 
                  BFD_ASSERT (rel->r_offset + 10 <= input_section->size);
3109
 
                  BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3110
 
                  BFD_ASSERT (bfd_get_8 (input_bfd,
3111
 
                                         contents + rel->r_offset + 9)
3112
 
                              == 0x90);
3113
3279
                  roff = rel->r_offset - 2;
3114
3280
                }
3115
3281
              memcpy (contents + roff,
3139
3305
                 leal x@tlsdesc(%ebx), %eax
3140
3306
 
3141
3307
                 Change it to:
3142
 
                 movl x@gotntpoff(%ebx), %eax # before nop; nop
 
3308
                 movl x@gotntpoff(%ebx), %eax # before xchg %ax,%ax
3143
3309
                 or:
3144
3310
                 movl x@gottpoff(%ebx), %eax # before negl %eax
3145
3311
 
3146
3312
                 Registers other than %eax may be set up here.  */
3147
3313
 
3148
 
              unsigned int val, type;
3149
3314
              bfd_vma roff;
3150
3315
 
3151
3316
              /* First, make sure it's a leal adding ebx to a 32-bit
3152
3317
                 offset into any register, although it's probably
3153
3318
                 almost always going to be eax.  */
3154
3319
              roff = rel->r_offset;
3155
 
              BFD_ASSERT (roff >= 2);
3156
 
              type = bfd_get_8 (input_bfd, contents + roff - 2);
3157
 
              BFD_ASSERT (type == 0x8d);
3158
 
              val = bfd_get_8 (input_bfd, contents + roff - 1);
3159
 
              BFD_ASSERT ((val & 0xc7) == 0x83);
3160
 
              BFD_ASSERT (roff + 4 <= input_section->size);
3161
3320
 
3162
3321
              /* Now modify the instruction as appropriate.  */
3163
3322
              /* To turn a leal into a movl in the form we use it, it
3185
3344
                 call *(%eax)
3186
3345
 
3187
3346
                 Change it to:
3188
 
                 nop; nop
 
3347
                 xchg %ax,%ax
3189
3348
                 or
3190
3349
                 negl %eax
3191
3350
                 depending on how we transformed the TLS_GOTDESC above.
3192
3351
              */
3193
3352
 
3194
 
              unsigned int val, type;
3195
3353
              bfd_vma roff;
3196
3354
 
3197
 
              /* First, make sure it's a call *(%eax).  */
3198
3355
              roff = rel->r_offset;
3199
 
              BFD_ASSERT (roff + 2 <= input_section->size);
3200
 
              type = bfd_get_8 (input_bfd, contents + roff);
3201
 
              BFD_ASSERT (type == 0xff);
3202
 
              val = bfd_get_8 (input_bfd, contents + roff + 1);
3203
 
              BFD_ASSERT (val == 0x10);
3204
3356
 
3205
3357
              /* Now modify the instruction as appropriate.  */
3206
3358
              if (tls_type != GOT_TLS_IE_NEG)
3223
3375
          break;
3224
3376
 
3225
3377
        case R_386_TLS_LDM:
3226
 
          if (! info->shared)
 
3378
          if (! elf_i386_tls_transition (info, input_bfd,
 
3379
                                         input_section, contents,
 
3380
                                         symtab_hdr, sym_hashes,
 
3381
                                         &r_type, GOT_UNKNOWN, rel,
 
3382
                                         relend, h))
 
3383
            return FALSE;
 
3384
 
 
3385
          if (r_type != R_386_TLS_LDM)
3227
3386
            {
3228
 
              unsigned int val;
3229
 
 
3230
3387
              /* LD->LE transition:
3231
 
                 Ensure it is:
3232
3388
                 leal foo(%reg), %eax; call ___tls_get_addr.
3233
3389
                 We change it into:
3234
3390
                 movl %gs:0, %eax; nop; leal 0(%esi,1), %esi.  */
3235
 
              BFD_ASSERT (rel->r_offset >= 2);
3236
 
              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
3237
 
                          == 0x8d);
3238
 
              val = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
3239
 
              BFD_ASSERT ((val & 0xf8) == 0x80 && (val & 7) != 4);
3240
 
              BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
3241
 
              BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
3242
 
                          == 0xe8);
3243
 
              BFD_ASSERT (rel + 1 < relend);
3244
 
              BFD_ASSERT (ELF32_R_TYPE (rel[1].r_info) == R_386_PLT32);
 
3391
              BFD_ASSERT (r_type == R_386_TLS_LE_32);
3245
3392
              memcpy (contents + rel->r_offset - 2,
3246
3393
                      "\x65\xa1\0\0\0\0\x90\x8d\x74\x26", 11);
3247
 
              /* Skip R_386_PLT32.  */
 
3394
              /* Skip R_386_PC32/R_386_PLT32.  */
3248
3395
              rel++;
3249
3396
              continue;
3250
3397
            }
3851
3998
#define bfd_elf32_bfd_is_local_label_name     elf_i386_is_local_label_name
3852
3999
#define bfd_elf32_bfd_link_hash_table_create  elf_i386_link_hash_table_create
3853
4000
#define bfd_elf32_bfd_reloc_type_lookup       elf_i386_reloc_type_lookup
 
4001
#define bfd_elf32_bfd_reloc_name_lookup elf_i386_reloc_name_lookup
3854
4002
 
3855
4003
#define elf_backend_adjust_dynamic_symbol     elf_i386_adjust_dynamic_symbol
3856
4004
#define elf_backend_check_relocs              elf_i386_check_relocs
3880
4028
#define TARGET_LITTLE_SYM               bfd_elf32_i386_freebsd_vec
3881
4029
#undef  TARGET_LITTLE_NAME
3882
4030
#define TARGET_LITTLE_NAME              "elf32-i386-freebsd"
 
4031
#undef  ELF_OSABI
 
4032
#define ELF_OSABI                       ELFOSABI_FREEBSD
3883
4033
 
3884
4034
/* The kernel recognizes executables as valid only if they carry a
3885
4035
   "FreeBSD" label in the ELF header.  So we put this label on all
3894
4044
  i_ehdrp = elf_elfheader (abfd);
3895
4045
 
3896
4046
  /* Put an ABI label supported by FreeBSD >= 4.1.  */
3897
 
  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
 
4047
  i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
3898
4048
#ifdef OLD_FREEBSD_ABI_LABEL
3899
4049
  /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
3900
4050
  memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
3914
4064
#define TARGET_LITTLE_SYM               bfd_elf32_i386_vxworks_vec
3915
4065
#undef  TARGET_LITTLE_NAME
3916
4066
#define TARGET_LITTLE_NAME              "elf32-i386-vxworks"
3917
 
 
 
4067
#undef  ELF_OSABI
3918
4068
 
3919
4069
/* Like elf_i386_link_hash_table_create but with tweaks for VxWorks.  */
3920
4070