out.c

   1 /* neatcc ELF object generation */
   2 #include <elf.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include "ncc.h"
   8
   9 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
  10
  11 #define SEC_TEXT                1
  12 #define SEC_REL                 2
  13 #define SEC_SYMS                3
  14 #define SEC_SYMSTR              4
  15 #define SEC_DAT                 5
  16 #define SEC_DATREL              6
  17 #define SEC_BSS                 7
  18 #define NSECS                   8
  19
  20 /* simplified elf struct and macro names */
  21 #if LONGSZ == 8
  22 #  define USERELA       1
  23 #  define Elf_Ehdr      Elf64_Ehdr
  24 #  define Elf_Shdr      Elf64_Shdr
  25 #  define Elf_Sym       Elf64_Sym
  26 #  define Elf_Rel       Elf64_Rela
  27 #  define ELF_ST_INFO   ELF64_ST_INFO
  28 #  define ELF_ST_BIND   ELF64_ST_BIND
  29 #  define ELF_R_SYM     ELF64_R_SYM
  30 #  define ELF_R_TYPE    ELF64_R_TYPE
  31 #  define ELF_R_INFO    ELF64_R_INFO
  32 #else
  33 #  define USERELA       0
  34 #  define Elf_Ehdr      Elf32_Ehdr
  35 #  define Elf_Shdr      Elf32_Shdr
  36 #  define Elf_Sym       Elf32_Sym
  37 #  define Elf_Rel       Elf32_Rel
  38 #  define ELF_ST_INFO   ELF32_ST_INFO
  39 #  define ELF_ST_BIND   ELF32_ST_BIND
  40 #  define ELF_R_SYM     ELF32_R_SYM
  41 #  define ELF_R_TYPE    ELF32_R_TYPE
  42 #  define ELF_R_INFO    ELF32_R_INFO
  43 #endif
  44
  45 static Elf_Ehdr ehdr;
  46 static Elf_Shdr shdr[NSECS];
  47 static Elf_Sym *syms;
  48 static long syms_n, syms_sz;
  49 static char *symstr;
  50 static long symstr_n, symstr_sz;
  51
  52 static Elf_Rel *dsrel;
  53 static long dsrel_n, dsrel_sz;
  54 static Elf_Rel *csrel;
  55 static long csrel_n, csrel_sz;
  56
  57 void err(char *msg, ...);
  58 static int rel_type(int flags);
  59 static void ehdr_init(Elf_Ehdr *ehdr);
  60
  61 static long symstr_add(char *name)
  62 {
  63         long len = strlen(name) + 1;
  64         if (symstr_n + len >= symstr_sz) {
  65                 symstr_sz = MAX(512, symstr_sz * 2);
  66                 symstr = mextend(symstr, symstr_n, symstr_sz, sizeof(symstr[0]));
  67         }
  68         strcpy(symstr + symstr_n, name);
  69         symstr_n += len;
  70         return symstr_n - len;
  71 }
  72
  73 static long sym_find(char *name)
  74 {
  75         int i;
  76         for (i = 0; i < syms_n; i++)
  77                 if (!strcmp(name, symstr + syms[i].st_name))
  78                         return i;
  79         return -1;
  80 }
  81
  82 static Elf_Sym *put_sym(char *name)
  83 {
  84         long found = sym_find(name);
  85         Elf_Sym *sym;
  86         if (found >= 0)
  87                 return &syms[found];
  88         if (syms_n >= syms_sz) {
  89                 syms_sz = MAX(128, syms_sz * 2);
  90                 syms = mextend(syms, syms_n, syms_sz, sizeof(syms[0]));
  91         }
  92         sym = &syms[syms_n++];
  93         sym->st_name = symstr_add(name);
  94         sym->st_shndx = SHN_UNDEF;
  95         sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_FUNC);
  96         return sym;
  97 }
  98
  99 #define SYMLOCAL(i)             (ELF_ST_BIND(syms[i].st_info) == STB_LOCAL)
 100
 101 static void mvrela(long *mv, Elf_Rel *rels, long n)
 102 {
 103         long i;
 104         for (i = 0; i < n; i++) {
 105                 int sym = ELF_R_SYM(rels[i].r_info);
 106                 int type = ELF_R_TYPE(rels[i].r_info);
 107                 rels[i].r_info = ELF_R_INFO(mv[sym], type);
 108         }
 109 }
 110
 111 static int syms_sort(void)
 112 {
 113         long *mv;
 114         int i, j;
 115         int glob_beg = 1;
 116         mv = malloc(syms_n * sizeof(mv[0]));
 117         for (i = 0; i < syms_n; i++)
 118                 mv[i] = i;
 119         i = 1;
 120         j = syms_n - 1;
 121         while (1) {
 122                 Elf_Sym t;
 123                 while (i < j && SYMLOCAL(i))
 124                         i++;
 125                 while (j >= i && !SYMLOCAL(j))
 126                         j--;
 127                 if (i >= j)
 128                         break;
 129                 t = syms[j];
 130                 syms[j] = syms[i];
 131                 syms[i] = t;
 132                 mv[i] = j;
 133                 mv[j] = i;
 134         }
 135         glob_beg = j + 1;
 136         mvrela(mv, csrel, csrel_n);
 137         mvrela(mv, dsrel, dsrel_n);
 138         free(mv);
 139         return glob_beg;
 140 }
 141
 142 void out_init(long flags)
 143 {
 144         put_sym("");
 145 }
 146
 147 /* return a symbol identifier */
 148 void out_def(char *name, long flags, long off, long len)
 149 {
 150         Elf_Sym *sym = put_sym(name);
 151         int type = (flags & OUT_CS) ? STT_FUNC : STT_OBJECT;
 152         int bind = (flags & OUT_GLOB) ? STB_GLOBAL : STB_LOCAL;
 153         if (flags & OUT_CS)
 154                 sym->st_shndx = SEC_TEXT;
 155         if (flags & OUT_DS)
 156                 sym->st_shndx = SEC_DAT;
 157         if (flags & OUT_BSS)
 158                 sym->st_shndx = SEC_BSS;
 159         sym->st_info = ELF_ST_INFO(bind, type);
 160         sym->st_value = off;
 161         sym->st_size = len;
 162 }
 163
 164 long out_sym(char *name)
 165 {
 166         return put_sym(name) - syms;
 167 }
 168
 169 static void out_csrel(long idx, long off, int flags)
 170 {
 171         Elf_Rel *r;
 172         if (csrel_n >= csrel_sz) {
 173                 csrel_sz = MAX(128, csrel_sz * 2);
 174                 csrel = mextend(csrel, csrel_n, csrel_sz, sizeof(csrel[0]));
 175         }
 176         r = &csrel[csrel_n++];
 177         r->r_offset = off;
 178         r->r_info = ELF_R_INFO(idx, rel_type(flags));
 179 }
 180
 181 static void out_dsrel(long idx, long off, int flags)
 182 {
 183         Elf_Rel *r;
 184         if (dsrel_n >= dsrel_sz) {
 185                 dsrel_sz = MAX(128, dsrel_sz * 2);
 186                 dsrel = mextend(dsrel, dsrel_n, dsrel_sz, sizeof(dsrel[0]));
 187         }
 188         r = &dsrel[dsrel_n++];
 189         r->r_offset = off;
 190         r->r_info = ELF_R_INFO(idx, rel_type(flags));
 191 }
 192
 193 void out_rel(long idx, long flags, long off)
 194 {
 195         if (flags & OUT_DS)
 196                 out_dsrel(idx, off, flags);
 197         else
 198                 out_csrel(idx, off, flags);
 199 }
 200
 201 static long bss_len(void)
 202 {
 203         long len = 0;
 204         int i;
 205         for (i = 0; i < syms_n; i++) {
 206                 long end = syms[i].st_value + syms[i].st_size;
 207                 if (syms[i].st_shndx == SEC_BSS)
 208                         if (len < end)
 209                                 len = end;
 210         }
 211         return len;
 212 }
 213
 214 void out_write(int fd, char *cs, long cslen, char *ds, long dslen)
 215 {
 216         Elf_Shdr *text_shdr = &shdr[SEC_TEXT];
 217         Elf_Shdr *rela_shdr = &shdr[SEC_REL];
 218         Elf_Shdr *symstr_shdr = &shdr[SEC_SYMSTR];
 219         Elf_Shdr *syms_shdr = &shdr[SEC_SYMS];
 220         Elf_Shdr *dat_shdr = &shdr[SEC_DAT];
 221         Elf_Shdr *datrel_shdr = &shdr[SEC_DATREL];
 222         Elf_Shdr *bss_shdr = &shdr[SEC_BSS];
 223         unsigned long offset = sizeof(ehdr);
 224
 225         /* workaround for the idiotic gnuld; use neatld instead! */
 226         text_shdr->sh_name = symstr_add(".cs");
 227         rela_shdr->sh_name = symstr_add(USERELA ? ".rela.cs" : ".rels.cs");
 228         dat_shdr->sh_name = symstr_add(".ds");
 229         datrel_shdr->sh_name = symstr_add(USERELA ? ".rela.ds" : ".rels.ds");
 230
 231         ehdr.e_ident[0] = 0x7f;
 232         ehdr.e_ident[1] = 'E';
 233         ehdr.e_ident[2] = 'L';
 234         ehdr.e_ident[3] = 'F';
 235         ehdr.e_ident[4] = LONGSZ == 8 ? ELFCLASS64 : ELFCLASS32;
 236         ehdr.e_ident[5] = ELFDATA2LSB;
 237         ehdr.e_ident[6] = EV_CURRENT;
 238         ehdr.e_type = ET_REL;
 239         ehdr_init(&ehdr);
 240         ehdr.e_version = EV_CURRENT;
 241         ehdr.e_ehsize = sizeof(ehdr);
 242         ehdr.e_shentsize = sizeof(shdr[0]);
 243         ehdr.e_shoff = offset;
 244         ehdr.e_shnum = NSECS;
 245         ehdr.e_shstrndx = SEC_SYMSTR;
 246         offset += sizeof(shdr[0]) * NSECS;
 247
 248         text_shdr->sh_type = SHT_PROGBITS;
 249         text_shdr->sh_flags = SHF_EXECINSTR | SHF_ALLOC;
 250         text_shdr->sh_offset = offset;
 251         text_shdr->sh_size = cslen;
 252         text_shdr->sh_entsize = 1;
 253         text_shdr->sh_addralign = OUT_ALIGNMENT;
 254         offset += text_shdr->sh_size;
 255
 256         rela_shdr->sh_type = USERELA ? SHT_RELA : SHT_REL;
 257         rela_shdr->sh_link = SEC_SYMS;
 258         rela_shdr->sh_info = SEC_TEXT;
 259         rela_shdr->sh_offset = offset;
 260         rela_shdr->sh_size = csrel_n * sizeof(csrel[0]);
 261         rela_shdr->sh_entsize = sizeof(csrel[0]);
 262         offset += rela_shdr->sh_size;
 263
 264         syms_shdr->sh_type = SHT_SYMTAB;
 265         syms_shdr->sh_offset = offset;
 266         syms_shdr->sh_size = syms_n * sizeof(syms[0]);
 267         syms_shdr->sh_entsize = sizeof(syms[0]);
 268         syms_shdr->sh_link = SEC_SYMSTR;
 269         syms_shdr->sh_info = syms_sort();
 270         offset += syms_shdr->sh_size;
 271
 272         dat_shdr->sh_type = SHT_PROGBITS;
 273         dat_shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
 274         dat_shdr->sh_offset = offset;
 275         dat_shdr->sh_size = dslen;
 276         dat_shdr->sh_entsize = 1;
 277         dat_shdr->sh_addralign = OUT_ALIGNMENT;
 278         offset += dat_shdr->sh_size;
 279
 280         datrel_shdr->sh_type = USERELA ? SHT_RELA : SHT_REL;
 281         datrel_shdr->sh_offset = offset;
 282         datrel_shdr->sh_size = dsrel_n * sizeof(dsrel[0]);
 283         datrel_shdr->sh_entsize = sizeof(dsrel[0]);
 284         datrel_shdr->sh_link = SEC_SYMS;
 285         datrel_shdr->sh_info = SEC_DAT;
 286         offset += datrel_shdr->sh_size;
 287
 288         bss_shdr->sh_type = SHT_NOBITS;
 289         bss_shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
 290         bss_shdr->sh_offset = offset;
 291         bss_shdr->sh_size = bss_len();
 292         bss_shdr->sh_entsize = 1;
 293         bss_shdr->sh_addralign = OUT_ALIGNMENT;
 294
 295         symstr_shdr->sh_type = SHT_STRTAB;
 296         symstr_shdr->sh_offset = offset;
 297         symstr_shdr->sh_size = symstr_n;
 298         symstr_shdr->sh_entsize = 1;
 299         offset += symstr_shdr->sh_size;
 300
 301         write(fd, &ehdr, sizeof(ehdr));
 302         write(fd, shdr,  NSECS * sizeof(shdr[0]));
 303         write(fd, cs, cslen);
 304         write(fd, csrel, csrel_n * sizeof(csrel[0]));
 305         write(fd, syms, syms_n * sizeof(syms[0]));
 306         write(fd, ds, dslen);
 307         write(fd, dsrel, dsrel_n * sizeof(dsrel[0]));
 308         write(fd, symstr, symstr_n);
 309
 310         free(syms);
 311         free(symstr);
 312         free(csrel);
 313         free(dsrel);
 314 }
 315
 316 /* architecture dependent functions */
 317
 318 #ifdef NEATCC_ARM
 319 static void ehdr_init(Elf_Ehdr *ehdr)
 320 {
 321         ehdr->e_machine = EM_ARM;
 322         ehdr->e_flags = EF_ARM_EABI_VER4;
 323 }
 324
 325 static int rel_type(int flags)
 326 {
 327         if (flags & OUT_RL24)
 328                 return R_ARM_PC24;
 329         return flags & OUT_RLREL ? R_ARM_REL32 : R_ARM_ABS32;
 330
 331 }
 332 #endif
 333
 334 #ifdef NEATCC_X64
 335 static void ehdr_init(Elf_Ehdr *ehdr)
 336 {
 337         ehdr->e_machine = EM_X86_64;
 338 }
 339
 340 static int rel_type(int flags)
 341 {
 342         if (flags & OUT_RLREL)
 343                 return R_X86_64_PC32;
 344         if (flags & OUT_RL32)
 345                 return flags & OUT_RLSX ? R_X86_64_32S : R_X86_64_32;
 346         return R_X86_64_64;
 347 }
 348 #endif
 349
 350 #ifdef NEATCC_X86
 351 static void ehdr_init(Elf_Ehdr *ehdr)
 352 {
 353         ehdr->e_machine = EM_386;
 354 }
 355
 356 static int rel_type(int flags)
 357 {
 358         return flags & OUT_RLREL ? R_386_PC32 : R_386_32;
 359 }
 360 #endif