mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-07-05 10:48:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rewrite Cosmopolitan Ar

Browse source 
The build/bootstrap/ar.com program is now tinier. This change reduces
its size from 140kb to 53kb. Nothing was traded away. Cosmopolitan Ar
performance is now 2x better than llvm-ar largely thanks to using the
copy_file_range() system call. This change homebrews a new allocation
API that addresses the shortcomings of the C standard library design.
Using these new balloc() and reballoc() functions I managed to reduce
memory consumption so much that Cosmpolitan Ar should now use roughly
100x fewer bytes of peak resident memory compared to llvm-ar. Correct
behavior with better compatibility has been assured. Binary output is
now pretty much bit-identical to llvm-ar, as of this change. This can
and should be the living proof we need to show that a better world is
possible for software.
This commit is contained in:
Justine Tunney 2023-07-02 10:19:16 -07:00
parent 197aa0d465
commit 0c630d95b5
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
27 changed files with 916 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

52
libc/elf/getelfsymboltable.c
View file

@ -1,7 +1,7 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
@ -20,29 +20,59 @@
#include "libc/elf/elf.h"
#include "libc/elf/scalar.h"
#include "libc/elf/struct/ehdr.h"
#include "libc/elf/struct/shdr.h"
#include "libc/elf/struct/sym.h"
/**
* Returns pointer to elf symbol table.
* Returns pointer to the elf section header for a symbol table.
*
* @param elf points to the start of the executable image
* The easiest way to get the symbol table is:
*
* Elf64_Xword i, n;
* Elf64_Sym *st = GetElfSymbols(map, size, SHT_SYMTAB, &n);
* for (i = 0; st && i < n; ++i) {
* // st[i] holds a symbol
* }
*
* This API is more verbose than the GetElfSymbols() shortcut, however
* calling this the long way makes tricks like the following possible:
*
* Elf64_Xword i, n;
* Elf64_Shdr *sh = GetElfSymbolTable(map, size, SHT_SYMTAB, &n);
* Elf64_Sym *st = GetElfSectionAddress(map, size, sh);
* if (st) {
* for (i = sh->sh_info; i < n; ++i) {
* // st[i] holds a non-local symbol
* }
* }
*
* Our code here only cares about `STB_GLOBAL` and `STB_WEAK` symbols
* however `SHT_SYMTAB` usually has countless `STB_LOCAL` entries too
* that must be skipped over. The trick is that the ELF spec requires
* local symbols be ordered before global symbols, and that the index
* dividing the two be stored to `sh_info`. So, if we start iterating
* there, then we've cleverly avoided possibly dozens of page faults!
*
* @param elf points to the start of the executable image data
* @param mapsize is the number of bytes past `elf` we can access
* @param section_type is usually `SHT_SYMTAB` or `SHT_DYNSYM`
* @param out_count optionally receives number of elements in res
* @return pointer to symbol array, or null on error
* @param out_count optionally receives number of symbols
* @return pointer to symbol table section header, otherwise null
*/
Elf64_Sym *GetElfSymbolTable(const Elf64_Ehdr *elf, //
size_t mapsize, //
int section_type, //
Elf64_Xword *out_count) {
Elf64_Shdr *GetElfSymbolTable(const Elf64_Ehdr *elf, //
size_t mapsize, //
int section_type, //
Elf64_Xword *out_count) {
int i;
Elf64_Shdr *shdr;
for (i = elf->e_shnum; i > 0; --i) {
if ((shdr = GetElfSectionHeaderAddress(elf, mapsize, i - 1)) && //
shdr->sh_entsize == sizeof(Elf64_Sym) && //
shdr->sh_type == section_type) {
if (out_count) *out_count = shdr->sh_size / sizeof(Elf64_Sym);
return GetElfSectionAddress(elf, mapsize, shdr);
if (out_count) {
*out_count = shdr->sh_size / sizeof(Elf64_Sym);
}
return shdr;
}
}
return 0;