mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
226aaf3547
This commit makes numerous refinements to cosmopolitan memory handling.
The default stack size has been reduced from 2mb to 128kb. A new macro
is now provided so you can easily reconfigure the stack size to be any
value you want. Work around the breaking change by adding to your main:
STATIC_STACK_SIZE(0x00200000); // 2mb stack
If you're not sure how much stack you need, then you can use:
STATIC_YOINK("stack_usage_logging");
After which you can `sort -nr o/$MODE/stack.log`. Based on the unit test
suite, nothing in the Cosmopolitan repository (except for Python) needs
a stack size greater than 30kb. There are also new macros for detecting
the size and address of the stack at runtime, e.g. GetStackAddr(). We
also now support sigaltstack() so if you want to see nice looking crash
reports whenever a stack overflow happens, you can put this in main():
ShowCrashReports();
Under `make MODE=dbg` and `make MODE=asan` the unit testing framework
will now automatically print backtraces of memory allocations when
things like memory leaks happen. Bugs are now fixed in ASAN global
variable overrun detection. The memtrack and asan runtimes also handle
edge cases now. The new tools helped to identify a few memory leaks,
which are fixed by this change.
This change should fix an issue reported in #288 with ARG_MAX limits.
Fixing this doubled the performance of MKDEPS.COM and AR.COM yet again.
681 lines
28 KiB
Text
681 lines
28 KiB
Text
/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8 -*-│
|
||
│vi: set et sts=2 tw=2 fenc=utf-8 :vi│
|
||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||
│ Copyright 2020 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 │
|
||
│ above copyright notice and this permission notice appear in all copies. │
|
||
│ │
|
||
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
||
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
||
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
||
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
||
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
||
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
||
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
||
│ PERFORMANCE OF THIS SOFTWARE. │
|
||
╠──────────────────────────────────────────────────────────────────────────────╣
|
||
│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
|
||
│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│
|
||
│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│
|
||
│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│
|
||
│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│
|
||
╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│
|
||
│ αcτµαlly pδrταblε εxεcµταblε § linker │
|
||
╚──────────────────────────────────────────────────────────────────────────────╝
|
||
Having an executable run natively on stock Windows / Mac / Linux / BSD
|
||
entails two steps: (1) create a .com.dbg binary w/ Linux toolchain and
|
||
then (2) unwrap the .com binary embedded within:
|
||
|
||
objcopy -S -O binary input.com.dbg output.com
|
||
|
||
Both executables will work fine, but only the .com format is portable.
|
||
|
||
───BUILDING─────────────────────────────────────────────────────────────
|
||
|
||
LC_ALL=C ld -T ape/ape.lds ...
|
||
|
||
───RUNNING──────────────────────────────────────────────────────────────
|
||
|
||
./foo.com.dbg # works on host machine
|
||
./foo.com # works on any os / arch
|
||
qemu-system-x86_64 -s foo.com # works on any os / arch
|
||
|
||
───BACKGROUND───────────────────────────────────────────────────────────
|
||
|
||
The purpose of this software is to help native programs have the same
|
||
level of consistency, in terms of user experience, that we enjoy with
|
||
web applications. It's basically like MeteorJS, except primarily CLI,
|
||
bootable, and more on the order of a few kilobytes than hundred megs.
|
||
|
||
Rather than Isomorphic JavaScript it's built using Isomorphic Binary,
|
||
since it grants the fastest possible performance and can be trivially
|
||
emulated in the browser. System resource utilization is also a few kb
|
||
and GUIs are possible too since Cosmopolitan exports the Windows API,
|
||
but we recommend doing it with a CLI web server instead and embedding
|
||
files in your αcτµαlly pδrταblε εxεcµταblε as it's isomorphic to zip.
|
||
|
||
Isomorphic Binary principles state that most platform differences are
|
||
just numbers, which we integrate easily into a unified business logic
|
||
through the use of a sufficiently powerful linker. System numbers are
|
||
otherwise known as ABIs and they're usually the most stable canonical
|
||
interfaces that platforms provide. This is how we are able to support
|
||
more versions of Linux than most Linux-only software, e.g. glibc FTMP
|
||
|
||
───DEBUGGING────────────────────────────────────────────────────────────
|
||
|
||
Can be done in a few ways:
|
||
|
||
gdb --tui foo.com.dbg
|
||
gdb --tui foo.com -ex 'add-symbol-file foo.com.dbg 0x200000'
|
||
gdb --tui -ex 'add-symbol-file foo.com.dbg 0x7c00' \
|
||
-ex 'add-symbol-file foo.com.dbg 0x200000' \
|
||
-ex -target remote localhost:1234'
|
||
|
||
───TRANSPARENCY─────────────────────────────────────────────────────────
|
||
|
||
αcτµαlly pδrταblε εxεcµταblε is designed to facilitate maximum
|
||
transparency to engender trust in this linker process.
|
||
|
||
The headers and symbols can be viewed using readelf or objdump:
|
||
|
||
readelf -Wa input.com.dbg # maximum transparency
|
||
objdump -wxd input.com.dbg # maximum transparency
|
||
|
||
The disassembly can be viewed using objdump:
|
||
|
||
readelf -Wa input.com.dbg # maximum transparency
|
||
objdump -d input.com.dbg # maximum transparency
|
||
objdump -dj.text input.com.dbg # skip αpε boilerplate
|
||
objdump -j.load -dMi8086 input.com.dbg # fixes real mode code
|
||
|
||
Some commands for controlling the verbosity of binaries:
|
||
|
||
strip -X input.com.dbg # remove ".L" symbols
|
||
strip input.com.dbg # remove all symbols
|
||
strip -S input.com.dbg # remove debug info only
|
||
make CPPFLAGS=-DNDEBUG # remove asserts (prod)
|
||
make CPPFLAGS=-DIM_FEELING_NAUGHTY # remove legal embeddings
|
||
|
||
The Makefile build is also configured to always produce a .map file
|
||
when building each program, which provides further details.
|
||
|
||
───HACKABILITY──────────────────────────────────────────────────────────
|
||
|
||
Your linker and assemblies were designed provide extensibility through
|
||
the use of link-time data structures we call "decentralized sections".
|
||
They allow functions like _init() to be comprised of many small pieces
|
||
defined throughout the codebase. The same applies to ELF / PE headers.
|
||
|
||
Extending that content usually entails writing a .S file. The process
|
||
has more in common with JavaScript programming than contemporary C++
|
||
development practices. It's the reason Cosmopolitan is able to build
|
||
the fast tiny multiplatform autonomous binaries that indie developers
|
||
love using a scalable development model that big businesses respect.
|
||
|
||
───SECURITY─────────────────────────────────────────────────────────────
|
||
|
||
αcτµαlly pδrταblε εxεcµταblε is designed to be secure in untrustworthy
|
||
computing environments. Code and data are separated. Data structures
|
||
initialized at startup are automatically memory protected afterwards.
|
||
Code intended for platforms you don't use is automatically unmapped
|
||
too, minimizing any possible chance of impacting your system, while
|
||
still being there in case you ever need it.
|
||
|
||
───CONFIDENTIALITY──────────────────────────────────────────────────────
|
||
|
||
αcτµαlly pδrταblε εxεcµταblε is also designed to not leak confidential
|
||
information by default. Details relating to the host build environment
|
||
such as system/library versions, user ids, home folder locations, etc.
|
||
are not taken into consideration at build time since it's hermetic. We
|
||
can't make speak for debug information, which is why it's put in other
|
||
files. We also provide the bing and fold programs for auditing binary.
|
||
|
||
───DESIGN─DETAILS───────────────────────────────────────────────────────
|
||
|
||
αcτµαlly pδrταblε εxεcµταblε is a non-reflective (a.k.a. flat) binary
|
||
format that includes ELF, PE, and Macho-O headers only to respect the
|
||
initialization rituals that supported platforms require.
|
||
|
||
Binaries are sparse because Intel's six thousand page manual says:
|
||
|
||
“Always put code and data on separate pages. [...] If code is
|
||
to be modified, try to do it all at once and make sure the
|
||
code that performs the modifications and the code being
|
||
modified are on separate 4KByte pages or on separate aligned
|
||
1-KByte subpages. [...] If (hopefully read-only) data must
|
||
occur on the same page as code, avoid placing it immediately
|
||
after an indirect jump [...] or inserting an illegal opcode
|
||
[...] after the indirect branch [which] may degrade perf in
|
||
some circumstances.” ──Intel V.O §3.6.9
|
||
|
||
Support for linking dynamic shared objects is only implemented on
|
||
Windows NT for the reasons described by Ulrich Drepper in his DSO
|
||
tutorial. We've implemented this independently of the ld codebase
|
||
because authentic GNU tooling is powerful enough to generalize to
|
||
arbitrary formats without needing to add features to its codebase.
|
||
|
||
Cosmopolitan core library functions may be converted to the COFF or
|
||
Mach-O object formats using objconv. That gives you some freedom to
|
||
choose to use the Microsoft or Apple linker instead of this one. We
|
||
otherwise can't use those formats, due to how they heavily restrict
|
||
naming, which basically makes everything we're doing impossible. In
|
||
the future an authentic GNU toolchain will be made available on the
|
||
Windows and Apple platforms, using canonical formats and behaviors.
|
||
Until then, we can build for those platforms using Linux or WSL. */
|
||
|
||
#ifdef __LINKER__
|
||
#include "ape/macros.internal.h"
|
||
#include "ape/relocations.h"
|
||
#include "libc/dce.h"
|
||
#include "libc/nt/pedef.internal.h"
|
||
#include "libc/zip.h"
|
||
|
||
ENTRY(_start)
|
||
|
||
PHDRS {
|
||
Head PT_LOAD FLAGS(5);
|
||
Rom PT_LOAD FLAGS(5);
|
||
Ram PT_LOAD FLAGS(6);
|
||
stack PT_GNU_STACK FLAGS(6);
|
||
}
|
||
|
||
SECTIONS {
|
||
|
||
/*BEGIN: realmode addressability guarantee */
|
||
/*BEGIN: xnu addressability guarantee */
|
||
/*BEGIN: linux addressability guarantee */
|
||
/*BEGIN: bsd addressability guarantee */
|
||
|
||
.head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) : AT(IMAGE_BASE_REAL) {
|
||
HIDDEN(_base = .);
|
||
|
||
/* Real Mode */
|
||
KEEP(*(.head))
|
||
KEEP(*(.apesh))
|
||
KEEP(*(.head2))
|
||
KEEP(*(.text.head))
|
||
|
||
/* Executable & Linkable Format */
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
HIDDEN(ape_phdrs = .);
|
||
KEEP(*(.elf.phdrs))
|
||
HIDDEN(ape_phdrs_end = .);
|
||
|
||
/* OpenBSD */
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
HIDDEN(ape_note = .);
|
||
KEEP(*(.note.openbsd.ident))
|
||
KEEP(*(.note.netbsd.ident))
|
||
HIDDEN(ape_note_end = .);
|
||
|
||
/* Portable Executable */
|
||
KEEP(*(.pe.header))
|
||
HIDDEN(ape_pe_sections = .);
|
||
KEEP(*(.pe.sections))
|
||
HIDDEN(ape_pe_sections_end = .);
|
||
|
||
/* Mach-O */
|
||
KEEP(*(.macho))
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
HIDDEN(ape_macho_end = .);
|
||
|
||
KEEP(*(.ape.pad.head))
|
||
. = ALIGN(SupportsWindows() || SupportsMetal() ? PAGESIZE : 16);
|
||
HIDDEN(_ehead = .);
|
||
} :Head
|
||
|
||
/*BEGIN: nt addressability guarantee */
|
||
|
||
.text . : {
|
||
BYTE(0x90) /* TODO: fix blinkenlights symbol __map_phdrs */
|
||
/* Code that needs to be addressable in Real Mode */
|
||
*(.text.real)
|
||
KEEP(*(SORT_BY_NAME(.sort.text.real.*)))
|
||
HIDDEN(_ereal = .);
|
||
. += 1;
|
||
|
||
/*END: realmode addressability guarantee */
|
||
|
||
/* Normal Code */
|
||
*(.start)
|
||
KEEP(*(.initprologue))
|
||
KEEP(*(SORT_BY_NAME(.init.*)))
|
||
KEEP(*(.init))
|
||
KEEP(*(.initepilogue))
|
||
KEEP(*(.pltprologue))
|
||
*(.plt)
|
||
KEEP(*(.pltepilogue))
|
||
KEEP(*(.pltgotprologue))
|
||
*(.plt.got)
|
||
KEEP(*(.pltgotepilogue))
|
||
*(.text.startup .text.startup.*)
|
||
*(.text.exit .text.exit.*)
|
||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||
*(SORT_BY_ALIGNMENT(.text.antiquity))
|
||
*(SORT_BY_ALIGNMENT(.text.antiquity.*))
|
||
KEEP(*(.textwindowsprologue))
|
||
*(.text.windows)
|
||
KEEP(*(.textwindowsepilogue))
|
||
*(SORT_BY_ALIGNMENT(.text.modernity))
|
||
*(SORT_BY_ALIGNMENT(.text.modernity.*))
|
||
*(SORT_BY_ALIGNMENT(.text.hot))
|
||
*(SORT_BY_ALIGNMENT(.text.hot.*))
|
||
KEEP(*(.keep.text))
|
||
*(.text .stub .text.*)
|
||
KEEP(*(SORT_BY_NAME(.sort.text.*)))
|
||
|
||
KEEP(*(.ape.pad.test));
|
||
*(.test.unlikely)
|
||
*(.test .test.*)
|
||
|
||
/* Privileged code invulnerable to magic */
|
||
KEEP(*(.ape.pad.privileged));
|
||
. += . > 0 ? 1 : 0;
|
||
HIDDEN(__privileged_start = .);
|
||
. += . > 0 ? 1 : 0;
|
||
*(.privileged)
|
||
HIDDEN(__privileged_end = .);
|
||
. += . > 0 ? 1 : 0;
|
||
|
||
/*BEGIN: Read Only Data */
|
||
|
||
KEEP(*(.ape.pad.rodata));
|
||
KEEP(*(.rodata.pytab.0));
|
||
KEEP(*(.rodata.pytab.1));
|
||
KEEP(*(.rodata.pytab.2));
|
||
|
||
*(.rodata .rodata.*)
|
||
*(.ubsan.types)
|
||
*(.ubsan.data)
|
||
|
||
/* Unit Test & Fixture Registry */
|
||
|
||
/*BEGIN: Read only data that needn't be mapped after initialization */
|
||
|
||
/* Legal Notices */
|
||
#if !defined(IM_FEELING_NAUGHTY) || defined(EMBED_NOTICES)
|
||
KEEP(*(.commentprologue))
|
||
KEEP(*(.comment))
|
||
KEEP(*(.commentepilogue))
|
||
#endif
|
||
|
||
/* Windows DLL Import Directory */
|
||
KEEP(*(.idata.ro));
|
||
KEEP(*(SORT_BY_NAME(.idata.ro.*)))
|
||
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
PROVIDE_HIDDEN(__init_array_start = .);
|
||
KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*)
|
||
SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||
KEEP(*(.ctors))
|
||
KEEP(*(.init_array))
|
||
KEEP(*(.preinit_array))
|
||
PROVIDE_HIDDEN(__init_array_end = .);
|
||
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
PROVIDE_HIDDEN(__fini_array_start = .);
|
||
KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*)
|
||
SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||
KEEP(*(.dtors))
|
||
PROVIDE_HIDDEN(__fini_array_end = .);
|
||
|
||
/* Encoded Data Structures w/ Linear Initialization Order */
|
||
KEEP(*(.initroprologue))
|
||
KEEP(*(SORT_BY_NAME(.initro.*)))
|
||
KEEP(*(.initroepilogue))
|
||
KEEP(*(SORT_BY_NAME(.sort.rodata.*)))
|
||
|
||
KEEP(*(.ape.pad.text))
|
||
. = ALIGN(PAGESIZE);
|
||
HIDDEN(_etext = .);
|
||
PROVIDE_HIDDEN(etext = .);
|
||
/*END: Read Only Data (only needed for initialization) */
|
||
/*END: Read Only Data */
|
||
} :Rom
|
||
|
||
.data . : {
|
||
/*BEGIN: Read/Write Data */
|
||
KEEP(*(.dataprologue))
|
||
*(.data .data.*)
|
||
KEEP(*(SORT_BY_NAME(.sort.data.*)))
|
||
. += . > 0 ? 1 : 0;
|
||
|
||
KEEP(*(.gotprologue))
|
||
*(.got)
|
||
KEEP(*(.gotepilogue))
|
||
|
||
KEEP(*(.gotpltprologue))
|
||
*(.got.plt)
|
||
KEEP(*(.gotpltepilogue))
|
||
|
||
/*BEGIN: Post-Initialization Read-Only */
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
KEEP(*(SORT_BY_NAME(.piro.relo.sort.*)))
|
||
PROVIDE_HIDDEN(__relo_end = .);
|
||
. = ALIGN(__SIZEOF_POINTER__);
|
||
KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
|
||
KEEP(*(.piro.pad.data))
|
||
. = ALIGN(PAGESIZE);
|
||
HIDDEN(_edata = .);
|
||
PROVIDE_HIDDEN(edata = .);
|
||
} :Ram
|
||
|
||
/*END: file content that's loaded by o/s */
|
||
/*BEGIN: payload (for now, only the APE loader) */
|
||
.payload ALIGN(64) : {
|
||
/* Loader */
|
||
HIDDEN(ape_loader = .);
|
||
KEEP(*(.ape.loader))
|
||
. = ALIGN(64);
|
||
HIDDEN(ape_loader_end = .);
|
||
}
|
||
/*END: payload */
|
||
/*BEGIN: bss memory void */
|
||
|
||
.zip . : {
|
||
KEEP(*(SORT_BY_NAME(.zip.*)))
|
||
HIDDEN(_ezip = .);
|
||
}
|
||
|
||
/*END: file content */
|
||
/*BEGIN: bss memory that's addressable */
|
||
|
||
.bss ALIGN(64) : {
|
||
KEEP(*(SORT_BY_NAME(.piro.bss.init.*)))
|
||
*(.piro.bss)
|
||
KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
|
||
HIDDEN(__piro_end = .);
|
||
. += . > 0 ? 1 : 0;
|
||
/*END: Post-Initialization Read-Only */
|
||
|
||
/* Statically Allocated Empty Space */
|
||
*(SORT_BY_ALIGNMENT(.bss))
|
||
*(SORT_BY_ALIGNMENT(.bss.*))
|
||
*(COMMON)
|
||
|
||
KEEP(*(SORT_BY_NAME(.sort.bss.*)))
|
||
|
||
. = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
|
||
HIDDEN(_end = .);
|
||
PROVIDE_HIDDEN(end = .);
|
||
}
|
||
|
||
/*END: nt addressability guarantee */
|
||
/*END: bsd addressability guarantee */
|
||
/*END: linux addressability guarantee */
|
||
/*END: xnu addressability guarantee */
|
||
|
||
.shstrtab : { *(.shstrtab) }
|
||
.strtab : { *(.strtab) }
|
||
.symtab : { *(.symtab) }
|
||
.stab 0 : { *(.stab) }
|
||
.stabstr 0 : { *(.stabstr) }
|
||
.stab.excl 0 : { *(.stab.excl) }
|
||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||
.stab.index 0 : { *(.stab.index) }
|
||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||
.comment 0 : { *(.comment) }
|
||
.debug 0 : { *(.debug) }
|
||
.line 0 : { *(.line) }
|
||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||
.debug_aranges 0 : { *(.debug_aranges) }
|
||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) }
|
||
.debug_frame 0 : { *(.debug_frame) }
|
||
.debug_str 0 : { *(.debug_str) }
|
||
.debug_loc 0 : { *(.debug_loc) }
|
||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||
.debug_typenames 0 : { *(.debug_typenames) }
|
||
.debug_varnames 0 : { *(.debug_varnames) }
|
||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||
.debug_ranges 0 : { *(.debug_ranges) }
|
||
.debug_macro 0 : { *(.debug_macro) }
|
||
.debug_addr 0 : { *(.debug_addr) }
|
||
.gnu.attributes 0 : { KEEP(*(.gnu.attributes)) }
|
||
.GCC.command.line 0 : { *(.GCC.command.line) }
|
||
|
||
/DISCARD/ : {
|
||
*(__mcount_loc)
|
||
*(.discard)
|
||
*(.yoink)
|
||
*(.*)
|
||
}
|
||
}
|
||
|
||
PFSTUB8(ape_elf_entry, _start);
|
||
PFSTUB8(ape_elf_phoff, RVA(ape_phdrs));
|
||
PFSTUB8(ape_elf_shoff, 0);
|
||
PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
|
||
PFSTUB4(ape_elf_shnum, 0);
|
||
PFSTUB4(ape_elf_shstrndx, 0);
|
||
|
||
HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE));
|
||
HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
|
||
ROUNDDOWN(__privileged_start, PAGESIZE)));
|
||
|
||
HIDDEN(ape_rom_offset = 0);
|
||
HIDDEN(ape_rom_vaddr = ADDR(.head));
|
||
HIDDEN(ape_rom_paddr = LOADADDR(.head));
|
||
HIDDEN(ape_rom_filesz = LOADADDR(.data) - ape_rom_paddr);
|
||
HIDDEN(ape_rom_memsz = ADDR(.data) - ADDR(.head));
|
||
HIDDEN(ape_rom_align = PAGESIZE);
|
||
HIDDEN(ape_rom_rva = RVA(ape_rom_vaddr));
|
||
|
||
HIDDEN(ape_ram_offset = ape_rom_offset + ape_rom_filesz);
|
||
HIDDEN(ape_ram_vaddr = ADDR(.data));
|
||
HIDDEN(ape_ram_paddr = LOADADDR(.data));
|
||
HIDDEN(ape_ram_filesz = SIZEOF(.data));
|
||
HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
|
||
HIDDEN(ape_ram_align = PAGESIZE);
|
||
HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));
|
||
|
||
HIDDEN(ape_stack_offset = ape_ram_offset + ape_ram_filesz);
|
||
HIDDEN(ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000 - STACKSIZE);
|
||
HIDDEN(ape_stack_paddr = ape_ram_paddr + ape_ram_filesz);
|
||
HIDDEN(ape_stack_filesz = 0);
|
||
HIDDEN(ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : STACKSIZE);
|
||
HIDDEN(ape_stack_align = 16);
|
||
|
||
HIDDEN(ape_note_offset = ape_rom_offset + (ape_note - ape_rom_vaddr));
|
||
HIDDEN(ape_note_vaddr = ape_note);
|
||
HIDDEN(ape_note_paddr = ape_rom_paddr + ape_note_offset);
|
||
HIDDEN(ape_note_filesz = ape_note_end - ape_note);
|
||
HIDDEN(ape_note_memsz = ape_note_filesz);
|
||
HIDDEN(ape_note_align = __SIZEOF_POINTER__);
|
||
|
||
HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
|
||
HIDDEN(ape_text_paddr = LOADADDR(.text));
|
||
HIDDEN(ape_text_vaddr = ADDR(.text));
|
||
HIDDEN(ape_text_filesz = SIZEOF(.text));
|
||
HIDDEN(ape_text_memsz = SIZEOF(.text));
|
||
HIDDEN(ape_text_align = PAGESIZE);
|
||
HIDDEN(ape_text_rva = RVA(ape_text_vaddr));
|
||
|
||
HIDDEN(ape_data_offset = ape_ram_offset + LOADADDR(.data) - ape_ram_paddr);
|
||
HIDDEN(ape_data_paddr = LOADADDR(.data));
|
||
HIDDEN(ape_data_vaddr = ADDR(.data));
|
||
HIDDEN(ape_data_filesz = SIZEOF(.data));
|
||
HIDDEN(ape_data_memsz = SIZEOF(.data));
|
||
HIDDEN(ape_data_align = PAGESIZE);
|
||
HIDDEN(ape_data_rva = RVA(ape_data_vaddr));
|
||
|
||
HIDDEN(ape_bss_offset = ape_ram_offset + LOADADDR(.bss) - ape_ram_paddr);
|
||
HIDDEN(ape_bss_paddr = LOADADDR(.bss));
|
||
HIDDEN(ape_bss_vaddr = ADDR(.bss));
|
||
HIDDEN(ape_bss_filesz = 0);
|
||
HIDDEN(ape_bss_memsz = SIZEOF(.bss));
|
||
HIDDEN(ape_bss_align = PAGESIZE);
|
||
|
||
SHSTUB2(ape_loader_dd_skip, RVA(ape_loader) / 64);
|
||
SHSTUB2(ape_loader_dd_count, (ape_loader_end - ape_loader) / 64);
|
||
|
||
#if SupportsXnu()
|
||
SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
|
||
SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
|
||
#endif
|
||
|
||
#if SupportsWindows() || SupportsMetal()
|
||
#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
|
||
PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
|
||
HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
|
||
HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
|
||
HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
|
||
HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
|
||
HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
|
||
HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
|
||
HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
|
||
HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
|
||
HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
|
||
HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
|
||
HIDDEN(v_ntsubsystem = (LINK_WINDOWS
|
||
? (DEFINED(GetMessage)
|
||
? kNtImageSubsystemWindowsGui
|
||
: kNtImageSubsystemWindowsCui)
|
||
: kNtImageSubsystemEfiApplication));
|
||
HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
|
||
#endif
|
||
|
||
#if SupportsMetal()
|
||
HIDDEN(v_ape_realsectors =
|
||
MIN(0x70000 - IMAGE_BASE_REAL,
|
||
ROUNDUP(RVA(_edata), 4096)) / 512);
|
||
HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
|
||
HIDDEN(v_ape_highsectors =
|
||
(ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
|
||
#endif
|
||
|
||
/* ZIP End of Central Directory header */
|
||
#define ZIPCONST(NAME, VAL) HIDDEN(NAME = DEFINED(__zip_start) ? VAL : 0);
|
||
ZIPCONST(v_zip_cdoffset, __zip_start - IMAGE_BASE_VIRTUAL);
|
||
ZIPCONST(v_zip_cdirsize, __zip_end - __zip_start);
|
||
ASSERT(v_zip_cdirsize % kZipCdirHdrLinkableSize == 0, "bad zip cdir");
|
||
ZIPCONST(v_zip_records, v_zip_cdirsize / kZipCdirHdrLinkableSize);
|
||
ZIPCONST(v_zip_commentsize, _ezip - __zip_end - kZipCdirHdrMinSize);
|
||
|
||
#if SupportsXnu()
|
||
/* Generates deterministic ID. */
|
||
#define PHI 0x9e3779b9925d4c17
|
||
#define XOR(X,Y) ((X | Y) - (X & Y))
|
||
#define XORSHIFT(X,Y) \
|
||
X = XOR(X, (Y >> 12)); \
|
||
X = XOR(X, (Y << 25)); \
|
||
X = XOR(X, (Y >> 27))
|
||
#define KMH(X,Y) \
|
||
X = (X + (Y >> 000) & 0xFF) * PHI; \
|
||
X = (X + (Y >> 010) & 0xFF) * PHI; \
|
||
X = (X + (Y >> 020) & 0xFF) * PHI; \
|
||
X = (X + (Y >> 030) & 0xFF) * PHI
|
||
#define CHURN(X) \
|
||
XORSHIFT(ape_uuid1, X); \
|
||
KMH(ape_uuid1, X); \
|
||
XORSHIFT(ape_uuid2, X); \
|
||
KMH(ape_uuid2, X)
|
||
HIDDEN(ape_uuid1 = 88172645463325252);
|
||
HIDDEN(ape_uuid2 = 88172645463325252);
|
||
CHURN(ape_bss_align);
|
||
CHURN(ape_bss_filesz);
|
||
CHURN(ape_bss_memsz);
|
||
CHURN(ape_bss_offset);
|
||
CHURN(ape_bss_paddr);
|
||
CHURN(ape_data_filesz);
|
||
CHURN(ape_data_memsz);
|
||
CHURN(ape_data_offset);
|
||
CHURN(ape_data_paddr);
|
||
CHURN(ape_data_rva);
|
||
CHURN(ape_data_vaddr);
|
||
CHURN(ape_elf_entry);
|
||
CHURN(ape_elf_phnum);
|
||
CHURN(ape_elf_phoff);
|
||
CHURN(ape_elf_shnum);
|
||
CHURN(ape_elf_shoff);
|
||
CHURN(ape_elf_shstrndx);
|
||
CHURN(ape_macho_end);
|
||
CHURN(ape_note);
|
||
CHURN(ape_note_align);
|
||
CHURN(ape_note_end);
|
||
CHURN(ape_note_filesz);
|
||
CHURN(ape_note_memsz);
|
||
CHURN(ape_note_offset);
|
||
CHURN(ape_note_paddr);
|
||
CHURN(ape_note_vaddr);
|
||
CHURN(ape_ram_align);
|
||
CHURN(ape_ram_filesz);
|
||
CHURN(ape_ram_memsz);
|
||
CHURN(ape_ram_offset);
|
||
CHURN(ape_ram_paddr);
|
||
CHURN(ape_ram_rva);
|
||
CHURN(ape_ram_vaddr);
|
||
CHURN(ape_rom_align);
|
||
CHURN(ape_rom_filesz);
|
||
CHURN(ape_rom_memsz);
|
||
CHURN(ape_rom_offset);
|
||
CHURN(ape_rom_paddr);
|
||
CHURN(ape_rom_rva);
|
||
CHURN(ape_rom_vaddr);
|
||
CHURN(ape_text_align);
|
||
CHURN(ape_text_filesz);
|
||
CHURN(ape_text_memsz);
|
||
CHURN(ape_text_offset);
|
||
CHURN(ape_text_paddr);
|
||
CHURN(ape_text_rva);
|
||
CHURN(ape_text_vaddr);
|
||
CHURN(ADDR(.bss));
|
||
CHURN(_start);
|
||
CHURN(ape_phdrs);
|
||
#if SupportsMetal()
|
||
CHURN(v_ape_realsectors);
|
||
#endif
|
||
#if SupportsXnu()
|
||
CHURN(ape_macho);
|
||
#endif
|
||
#if SupportsWindows() || SupportsMetal()
|
||
CHURN(ape_mz);
|
||
CHURN(ape_pe);
|
||
CHURN(ape_pe_offset);
|
||
CHURN(ape_pe_optsz);
|
||
CHURN(ape_pe_sections);
|
||
CHURN(ape_pe_sections_end);
|
||
CHURN(ape_pe_shnum);
|
||
CHURN(ape_phdrs_end);
|
||
CHURN(WinMain);
|
||
#endif /* SupportsWindows() */
|
||
#endif /* SupportsXnu() */
|
||
|
||
ASSERT(DEFINED(ape_mz) ? ape_mz == IMAGE_BASE_VIRTUAL : 1, "linker panic");
|
||
ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0,
|
||
"__init_bss misalign");
|
||
ASSERT(((DEFINED(__init_rodata_end) ? __init_rodata_end : 0) %
|
||
__SIZEOF_POINTER__ == 0),
|
||
"__init_rodata misalign");
|
||
|
||
ASSERT((!DEFINED(ape_grub) ? 1 : RVA(ape_grub) < 8192),
|
||
"grub stub needs to be in first 8kb of image");
|
||
|
||
ASSERT(DEFINED(_start) || DEFINED(_start16),
|
||
"please link a _start() or _start16() entrypoint");
|
||
|
||
ASSERT(!DEFINED(_start16) || REAL(_end) < 65536,
|
||
"ape won't support non-tiny real mode programs");
|
||
|
||
/* Let's not be like Knight Capital. */
|
||
/* NOCROSSREFS_TO(.test .text) */
|
||
|
||
/* ASSERT(ape_sysv_start == ape_text_vaddr, */
|
||
/* "ape_sysv_start() must be first in .text"); */
|
||
|
||
#endif /* __LINKER__ */
|