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             return 0;
  41
  42         case R_386_PC16:
  43         case R_386_PC32:
  44         case R_386_PLT32:
  45         case R_386_JMP_SLOT:
  46             return 1;
  47     }
  48     return -1;
  49 }
  50
  51 /* Returns an enumerator to describe whether and when the relocation needs a
  52    GOT and/or PLT entry to be created. See tcc.h for a description of the
  53    different values. */
  54 int gotplt_entry_type (int reloc_type)
  55 {
  56     switch (reloc_type) {
  57         case R_386_RELATIVE:
  58         case R_386_16:
  59         case R_386_GLOB_DAT:
  60         case R_386_JMP_SLOT:
  61         case R_386_COPY:
  62             return NO_GOTPLT_ENTRY;
  63
  64         case R_386_32:
  65             /* This relocations shouldn't normally need GOT or PLT
  66                slots if it weren't for simplicity in the code generator.
  67                See our caller for comments.  */
  68             return AUTO_GOTPLT_ENTRY;
  69
  70         case R_386_PC16:
  71         case R_386_PC32:
  72             return AUTO_GOTPLT_ENTRY;
  73
  74         case R_386_GOTPC:
  75         case R_386_GOTOFF:
  76             return BUILD_GOT_ONLY;
  77
  78         case R_386_GOT32:
  79         case R_386_GOT32X:
  80         case R_386_PLT32:
  81             return ALWAYS_GOTPLT_ENTRY;
  82     }
  83     return -1;
  84 }
  85
  86 ST_FUNC unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr)
  87 {
  88     Section *plt = s1->plt;
  89     uint8_t *p;
  90     int modrm;
  91     unsigned plt_offset, relofs;
  92
  93     /* on i386 if we build a DLL, we add a %ebx offset */
  94     if (s1->output_type == TCC_OUTPUT_DLL)
  95         modrm = 0xa3;
  96     else
  97         modrm = 0x25;
  98
  99     /* empty PLT: create PLT0 entry that pushes the library identifier
 100        (GOT + PTR_SIZE) and jumps to ld.so resolution routine
 101        (GOT + 2 * PTR_SIZE) */
 102     if (plt->data_offset == 0) {
 103         p = section_ptr_add(plt, 16);
 104         p[0] = 0xff; /* pushl got + PTR_SIZE */
 105         p[1] = modrm + 0x10;
 106         write32le(p + 2, PTR_SIZE);
 107         p[6] = 0xff; /* jmp *(got + PTR_SIZE * 2) */
 108         p[7] = modrm;
 109         write32le(p + 8, PTR_SIZE * 2);
 110     }
 111     plt_offset = plt->data_offset;
 112
 113     /* The PLT slot refers to the relocation entry it needs via offset.
 114        The reloc entry is created below, so its offset is the current
 115        data_offset */
 116     relofs = s1->got->reloc ? s1->got->reloc->data_offset : 0;
 117
 118     /* Jump to GOT entry where ld.so initially put the address of ip + 4 */
 119     p = section_ptr_add(plt, 16);
 120     p[0] = 0xff; /* jmp *(got + x) */
 121     p[1] = modrm;
 122     write32le(p + 2, got_offset);
 123     p[6] = 0x68; /* push $xxx */
 124     write32le(p + 7, relofs);
 125     p[11] = 0xe9; /* jmp plt_start */
 126     write32le(p + 12, -(plt->data_offset));
 127     return plt_offset;
 128 }
 129
 130 /* relocate the PLT: compute addresses and offsets in the PLT now that final
 131    address for PLT and GOT are known (see fill_program_header) */
 132 ST_FUNC void relocate_plt(TCCState *s1)
 133 {
 134     uint8_t *p, *p_end;
 135
 136     if (!s1->plt)
 137       return;
 138
 139     p = s1->plt->data;
 140     p_end = p + s1->plt->data_offset;
 141
 142     if (p < p_end) {
 143         add32le(p + 2, s1->got->sh_addr);
 144         add32le(p + 8, s1->got->sh_addr);
 145         p += 16;
 146         while (p < p_end) {
 147             add32le(p + 2, s1->got->sh_addr);
 148             p += 16;
 149         }
 150     }
 151 }
 152 #endif
 153
 154 void relocate(TCCState *s1, ElfW_Rel *rel, int type, unsigned char *ptr, addr_t addr, addr_t val)
 155 {
 156     int sym_index, esym_index;
 157
 158     sym_index = ELFW(R_SYM)(rel->r_info);
 159
 160     switch (type) {
 161         case R_386_32:
 162             if (s1->output_type == TCC_OUTPUT_DLL) {
 163                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
 164                 qrel->r_offset = rel->r_offset;
 165                 if (esym_index) {
 166                     qrel->r_info = ELFW(R_INFO)(esym_index, R_386_32);
 167                     qrel++;
 168                     return;
 169                 } else {
 170                     qrel->r_info = ELFW(R_INFO)(0, R_386_RELATIVE);
 171                     qrel++;
 172                 }
 173             }
 174             add32le(ptr, val);
 175             return;
 176         case R_386_PC32:
 177             if (s1->output_type == TCC_OUTPUT_DLL) {
 178                 /* DLL relocation */
 179                 esym_index = get_sym_attr(s1, sym_index, 0)->dyn_index;
 180                 if (esym_index) {
 181                     qrel->r_offset = rel->r_offset;
 182                     qrel->r_info = ELFW(R_INFO)(esym_index, R_386_PC32);
 183                     qrel++;
 184                     return;
 185                 }
 186             }
 187             add32le(ptr, val - addr);
 188             return;
 189         case R_386_PLT32:
 190             add32le(ptr, val - addr);
 191             return;
 192         case R_386_GLOB_DAT:
 193         case R_386_JMP_SLOT:
 194             write32le(ptr, val);
 195             return;
 196         case R_386_GOTPC:
 197             add32le(ptr, s1->got->sh_addr - addr);
 198             return;
 199         case R_386_GOTOFF:
 200             add32le(ptr, val - s1->got->sh_addr);
 201             return;
 202         case R_386_GOT32:
 203         case R_386_GOT32X:
 204             /* we load the got offset */
 205             add32le(ptr, get_sym_attr(s1, sym_index, 0)->got_offset);
 206             return;
 207         case R_386_16:
 208             if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
 209             output_file:
 210                 tcc_error("can only produce 16-bit binary files");
 211             }
 212             write16le(ptr, read16le(ptr) + val);
 213             return;
 214         case R_386_PC16:
 215             if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY)
 216                 goto output_file;
 217             write16le(ptr, read16le(ptr) + val - addr);
 218             return;
 219         case R_386_RELATIVE:
 220 #ifdef TCC_TARGET_PE
 221             add32le(ptr, val - s1->pe_imagebase);
 222 #endif
 223             /* do nothing */
 224             return;
 225         case R_386_COPY:
 226             /* This relocation must copy initialized data from the library
 227             to the program .bss segment. Currently made like for ARM
 228             (to remove noise of default case). Is this true?
 229             */
 230             return;
 231         default:
 232             fprintf(stderr,"FIXME: handle reloc type %d at %x [%p] to %x\n",
 233                 type, (unsigned)addr, ptr, (unsigned)val);
 234             return;
 235     }
 236 }
 237
 238 #endif /* !TARGET_DEFS_ONLY */