i386-link.c

   1 #ifdef TARGET_DEFS_ONLY
   2
   3 #define EM_TCC_TARGET EM_386
   4
   5 /* relocation type for 32 bit data relocation */
   6 #define R_DATA_32   R_386_32
   7 #define R_DATA_PTR  R_386_32
   8 #define R_JMP_SLOT  R_386_JMP_SLOT
   9 #define R_GLOB_DAT  R_386_GLOB_DAT
  10 #define R_COPY      R_386_COPY
  11 #define R_RELATIVE  R_386_RELATIVE
  12
  13 #define R_NUM       R_386_NUM
  14
  15 #define ELF_START_ADDR 0x08048000
  16 #define ELF_PAGE_SIZE  0x1000
  17
  18 #define PCRELATIVE_DLLPLT 0
  19 #define RELOCATE_DLLPLT 0
  20
  21 #else /* !TARGET_DEFS_ONLY */
  22
  23 #include "tcc.h"
  24
  25 #ifndef ELF_OBJ_ONLY
  26 /* Returns 1 for a code relocation, 0 for a data relocation. For unknown
  27    relocations, returns -1. */
  28 int code_reloc (int reloc_type)
  29 {
  30     switch (reloc_type) {
  31         case R_386_RELATIVE:
  32         case R_386_16:
  33         case R_386_32:
  34         case R_386_GOTPC:
  35         case R_386_GOTOFF:
  36         case R_386_GOT32:
  37         case R_386_GOT32X:
  38         case R_386_GLOB_DAT:
  39         case R_386_COPY:
  40         case R_386_TLS_GD:
  41         case R_386_TLS_LDM:
  42         case R_386_TLS_LDO_32:
  43         case R_386_TLS_LE:
  44             return 0;
  45
  46         case R_386_PC16:
  47         case R_386_PC32:
  48         case R_386_PLT32:
  49         case R_386_JMP_SLOT:
  50             return 1;
  51     }
  52     return -1;
  53 }
  54
  55 /* Returns an enumerator to describe whether and when the relocation needs a
  56    GOT and/or PLT entry to be created. See tcc.h for a description of the
  57    different values. */
  58 int gotplt_entry_type (int reloc_type)
  59 {
  60     switch (reloc_type) {
  61         case R_386_RELATIVE:
  62         case R_386_16:
  63         case R_386_GLOB_DAT:
  64         case R_386_JMP_SLOT:
  65         case R_386_COPY:
  66             return NO_GOTPLT_ENTRY;
  67
  68         case R_386_32:
  69             /* This relocations shouldn't normally need GOT or PLT
  70                slots if it weren't for simplicity in the code generator.
  71                See our caller for comments.  */
  72             return AUTO_GOTPLT_ENTRY;
  73
  74         case R_386_PC16:
  75         case R_386_PC32:
  76             return AUTO_GOTPLT_ENTRY;
  77
  78         case R_386_GOTPC:
  79         case R_386_GOTOFF:
  80             return BUILD_GOT_ONLY;
  81
  82         case R_386_GOT32:
  83         case R_386_GOT32X:
  84         case R_386_PLT32:
  85         case R_386_TLS_GD:
  86         case R_386_TLS_LDM:
  87         case R_386_TLS_LDO_32:
  88         case R_386_TLS_LE:
  89             return ALWAYS_GOTPLT_ENTRY;
  90     }
  91     return -1;
  92 }
  93
  94 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
  95 {
  96     Section *plt = s1->plt;
  97     uint8_t *p;
  98     int modrm;
  99     unsigned plt_offset, relofs;
 100
 101     /* on i386 if we build a DLL, we add a %ebx offset */
 102     if (s1->output_type == TCC_OUTPUT_DLL)
 103         modrm = 0xa3;
 104     else
 105         modrm = 0x25;
 106
 107     /* empty PLT: create PLT0 entry that pushes the library identifier
 108        (GOT + PTR_SIZE) and jumps to ld.so resolution routine
 109        (GOT + 2 * PTR_SIZE) */
 110     if (plt->data_offset == 0) {
 111         p = section_ptr_add(plt, 16);
 112         p[0] = 0xff; /* pushl got + PTR_SIZE */
 113         p[1] = modrm + 0x10;
 114         write32le(p + 2, PTR_SIZE);
 115         p[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
 116         p[7] = modrm;
 117         write32le(p + 8, PTR_SIZE * 2);
 118     }
 119     plt_offset = plt->data_offset;
 120
 121     /* The PLT slot refers to the relocation entry it needs via offset.
 122        The reloc entry is created below, so its offset is the current
 123        data_offset */
 124     relofs = s1->got->reloc ? s1->got->reloc->data_offset : 0;
 125
 126     /* Jump to GOT entry where ld.so initially put the address of ip + 4 */
 127     p = section_ptr_add(plt, 16);
 128     p[0] = 0xff; /* jmp *(got + x) */
 129     p[1] = modrm;
 130     write32le(p + 2, got_offset);
 131     p[6] = 0x68; /* push $xxx */
 132     write32le(p + 7, relofs);
 133     p[11] = 0xe9; /* jmp plt_start */
 134     write32le(p + 12, -(plt->data_offset));
 135     return plt_offset;
 136 }
 137
 138 /* relocate the PLT: compute addresses and offsets in the PLT now that final
 139    address for PLT and GOT are known (see fill_program_header) */
 140 ST_FUNC void relocate_plt(TCCState *s1)
 141 {
 142     uint8_t *p, *p_end;
 143
 144     if (!s1->plt)
 145       return;
 146
 147     p = s1->plt->data;
 148     p_end = p + s1->plt->data_offset;
 149
 150     if (p < p_end) {
 151         add32le(p + 2, s1->got->sh_addr);
 152         add32le(p + 8, s1->got->sh_addr);
 153         p += 16;
 154         while (p < p_end) {
 155             add32le(p + 2, s1->got->sh_addr);
 156             p += 16;
 157         }
 158     }
 159 }
 160 #endif
 161
 162 void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val)
 163 {
 164     int sym_index, esym_index;
 165
 166     sym_index = ELFW(R_SYM)(rel->r_info);
 167
 168     switch (type) {
 169         case R_386_32:
 170             if (s1->output_type == TCC_OUTPUT_DLL) {
 171                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
 172                 qrel->r_offset = rel->r_offset;
 173                 if (esym_index) {
 174                     qrel->r_info = ELFW(R_INFO)(esym_index, R_386_32);
 175                     qrel++;
 176                     return;
 177                 } else {
 178                     qrel->r_info = ELFW(R_INFO)(0, R_386_RELATIVE);
 179                     qrel++;
 180                 }
 181             }
 182             add32le(ptr, val);
 183             return;
 184         case R_386_PC32:
 185             if (s1->output_type == TCC_OUTPUT_DLL) {
 186                 /* DLL relocation */
 187                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
 188                 if (esym_index) {
 189                     qrel->r_offset = rel->r_offset;
 190                     qrel->r_info = ELFW(R_INFO)(esym_index, R_386_PC32);
 191                     qrel++;
 192                     return;
 193                 }
 194             }
 195             add32le(ptr, val - addr);
 196             return;
 197         case R_386_PLT32:
 198             add32le(ptr, val - addr);
 199             return;
 200         case R_386_GLOB_DAT:
 201         case R_386_JMP_SLOT:
 202             write32le(ptr, val);
 203             return;
 204         case R_386_GOTPC:
 205             add32le(ptr, s1->got->sh_addr - addr);
 206             return;
 207         case R_386_GOTOFF:
 208             add32le(ptr, val - s1->got->sh_addr);
 209             return;
 210         case R_386_GOT32:
 211         case R_386_GOT32X:
 212             /* we load the got offset */
 213             add32le(ptr, get_sym_attr(s1, sym_index, 0)->got_offset);
 214             return;
 215         case R_386_16:
 216             if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
 217             output_file:
 218                 tcc_error("can only produce 16-bit binary files");
 219             }
 220             write16le(ptr, read16le(ptr) + val);
 221             return;
 222         case R_386_PC16:
 223             if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY)
 224                 goto output_file;
 225             write16le(ptr, read16le(ptr) + val - addr);
 226             return;
 227         case R_386_RELATIVE:
 228 #ifdef TCC_TARGET_PE
 229             add32le(ptr, val - s1->pe_imagebase);
 230 #endif
 231             /* do nothing */
 232             return;
 233         case R_386_COPY:
 234             /* This relocation must copy initialized data from the library
 235             to the program .bss segment. Currently made like for ARM
 236             (to remove noise of default case). Is this true?
 237             */
 238             return;
 239         case R_386_TLS_GD:
 240             {
 241                 static const unsigned char expect[] = {
 242                     /* lea 0(,%ebx,1),%eax */
 243                     0x8d, 0x04, 0x1d, 0x00, 0x00, 0x00, 0x00,
 244                     /* call __tls_get_addr@PLT */
 245                     0xe8, 0xfc, 0xff, 0xff, 0xff };
 246                 static const unsigned char replace[] = {
 247                     /* mov %gs:0,%eax */
 248                     0x65, 0xa1, 0x00, 0x00, 0x00, 0x00,
 249                     /* sub 0,%eax */
 250                     0x81, 0xe8, 0x00, 0x00, 0x00, 0x00 };
 251
 252                 if (memcmp (ptr-3, expect, sizeof(expect)) == 0) {
 253                     ElfW(Sym) *sym;
 254                     Section *sec;
 255                     int32_t x;
 256
 257                     memcpy(ptr-3, replace, sizeof(replace));
 258                     rel[1].r_info = ELFW(R_INFO)(0, R_386_NONE);
 259                     sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
 260                     sec = s1->sections[sym->st_shndx];
 261                     x = sym->st_value - sec->sh_addr - sec->data_offset;
 262                     add32le(ptr + 5, -x);
 263                 }
 264                 else
 265                     tcc_error("unexpected R_386_TLS_GD pattern");
 266             }
 267             return;
 268         case R_386_TLS_LDM:
 269             {
 270                 static const unsigned char expect[] = {
 271                     /* lea 0(%ebx),%eax */
 272                     0x8d, 0x83, 0x00, 0x00, 0x00, 0x00,
 273                     /* call __tls_get_addr@PLT */
 274                     0xe8, 0xfc, 0xff, 0xff, 0xff };
 275                 static const unsigned char replace[] = {
 276                     /* mov %gs:0,%eax */
 277                     0x65, 0xa1, 0x00, 0x00, 0x00, 0x00,
 278                     /* nop */
 279                     0x90,
 280                     /* lea 0(%esi,%eiz,1),%esi */
 281                     0x8d, 0x74, 0x26, 0x00 };
 282
 283                 if (memcmp (ptr-2, expect, sizeof(expect)) == 0) {
 284                     memcpy(ptr-2, replace, sizeof(replace));
 285                     rel[1].r_info = ELFW(R_INFO)(0, R_386_NONE);
 286                 }
 287                 else
 288                     tcc_error("unexpected R_386_TLS_LDM pattern");
 289             }
 290             return;
 291         case R_386_TLS_LDO_32:
 292         case R_386_TLS_LE:
 293             {
 294                 ElfW(Sym) *sym;
 295                 Section *sec;
 296                 int32_t x;
 297
 298                 sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
 299                 sec = s1->sections[sym->st_shndx];
 300                 x = val - sec->sh_addr - sec->data_offset;
 301                 add32le(ptr, x);
 302             }
 303             return;
 304         case R_386_NONE:
 305             return;
 306         default:
 307             fprintf(stderr,"FIXME: handle reloc type %d at %x [%p] to %x\n",
 308                 type, (unsigned)addr, ptr, (unsigned)val);
 309             return;
 310     }
 311 }
 312
 313 #endif /* !TARGET_DEFS_ONLY */