wip: rollup of aarch64 changes

Author: m-hilgendorf

packages/std/packages/stub/include/aarch64/util.h

@@ -1,34 +1,16 @@
 #pragma once
-#include <stddef.h>
-#include <stdint.h>
-
-static void* memcpy (
-	void*		dst, 
-	const void*	src, 
-	size_t		len
-) {
-	for (size_t i = 0; i < len; i++) {
-		((uint8_t*)dst)[i] = ((const uint8_t*)src)[i];
-	}
-}
-
-static void* memset (
-	void* dst,
-	int c, 
-	size_t n
-) {
-	for (size_t i = 0; i < n; i++) {
-		((uint8_t*)dst)[i] = (uint8_t)(c);
-	}
-	return dst;
-}
 
 static void jump_to_entrypoint (void* stack, void* entrypoint) {
+	register long x0 asm("x0") = (long)stack;
+	register long x1 asm("x1") = (long)entrypoint;
 	asm volatile (
 		"mov sp, x0;"		// set the stack pointer.
 		"mov x29, xzr;"		// clear the frame pointer.
 		"mov x0, xzr;"		// clear atexit pointer
 		"br x1;"		// jump to the entrypoint
+		:
+		: "r"(x0), "r"(x1)
+		: "memory", "cc"
 	);
 	__builtin_unreachable();
 }

packages/std/packages/stub/include/util.h

@@ -24,6 +24,9 @@ typedef struct {
 	uint64_t len;
 } String;
 
+void* memcpy (void* dst, const void* src, size_t len);
+void* memset (void* dst, int c, size_t n);
+
 // Get the length of a string including the null byte.
 static size_t strlen_including_nul (const char* str) {
 	size_t len = 0;

packages/std/packages/stub/include/x86_64/util.h

@@ -1,38 +1,6 @@
 #pragma once
 #include <stddef.h>
 
-// Memcpy implementation.
-__attribute__((naked))
-static void* memcpy (
-	void*		dst, 
-	const void*	src, 
-	size_t		len
-) {
-	asm volatile (
-		"rep rex.w movsb;"
-		"ret;" 
-		: "+D"(dst), "+S"(src), "+c"(len) 
-		:
-		: "memory", "cc"
-	);
-}
-
-// Memset implementation.
-__attribute__((naked))
-static void* memset (
-	void* dst,
-	int c, 
-	size_t n
-) {
-	asm volatile (
-		"rep rex.w stosb;"
-		"ret;" 
-		: "+D"(dst), "+c"(n) 
-		: "a"(c) 
-		: "memory", "cc"
-	);
-}
-
 __attribute__((naked)) 
 static void jump_to_entrypoint (void* stack, void* entrypoint) {
 	asm volatile (

packages/std/packages/stub/src/aarch64/start.s

@@ -4,4 +4,4 @@
 _start:
 	mov x29, xzr
 	mov x0, sp
-	bl  _stub_start
+	bl  main

packages/std/packages/stub/src/aarch64/start2.s

@@ -4,13 +4,11 @@
 #error "unknown architecture"
 #endif
 
-// Common includes.
 #include <stddef.h>
 #include <stdint.h>
 #include <elf.h>
 #include <stdbool.h>
 
-// Internals.
 #include "arena.h"
 #include "debug.h"
 #include "footer.h"
@@ -807,7 +805,7 @@ static void exec (Arena* arena, Manifest* manifest, char* argv0, Options* option
 }
 
 // Main entrypoint.
-void _stub_start (void *sp) {
+void main (void *sp) {
 	// State.
 	Arena arena = {0};
 	Footer footer = {0};

packages/std/packages/stub/src/stub.c

@@ -10,11 +10,9 @@
 #include <unistd.h>
 
 #ifdef __aarch64__
-	#define PAGE_SIZE 0x10000
 	#define MACHINE EM_AARCH64
 #endif
 #ifdef __x86_64__
-	#define PAGE_SIZE 0x1000
 	#define MACHINE EM_X86_64
 #endif
 
@@ -51,6 +49,7 @@ typedef struct Analysis Analysis;
 struct Analysis {
 	Elf64_Phdr*	pt_interp;
 	Elf64_Addr	max_vaddr;
+	Elf64_Addr	max_align;
 };
 
 typedef struct ProgramHeaders ProgramHeaders;
@@ -127,12 +126,15 @@ Analysis elf_analyze (Elf elf) {
 	Elf64_Phdr* end = itr + elf.ehdr->e_phnum;
 	int i = 0;
 	for(; itr != end; itr++) {
-		if (itr->p_type != PT_LOAD) {
+		if (itr->p_type == PT_LOAD) {
 			Elf64_Addr end_of_segment = itr->p_vaddr + itr->p_memsz;
 			TRACE("phdr[%d] vaddr:%lx memsz:%lx, end:%lx", i++, itr->p_vaddr, itr->p_memsz, end_of_segment);
 			if (end_of_segment > analysis.max_vaddr) {
 				analysis.max_vaddr = end_of_segment;
 			}
+			if (itr->p_align > analysis.max_align) {
+				analysis.max_align = itr->p_align;
+			}
 		}
 		if (itr->p_type == PT_INTERP) {
 			ABORT_IF(analysis.pt_interp, "multiple interpreters found");
@@ -143,6 +145,35 @@ Analysis elf_analyze (Elf elf) {
 	return analysis;
 }
 
+
+// Bubble sort loadable segments
+void elf_sort_segments (Elf64_Phdr* phdr, size_t num) {
+	TRACE("num segments = %d", num);
+	Elf64_Addr start_addr, end_addr;
+	for(;;) {
+		bool swapped = false;
+		for (int n = 0; n < (num - 1); n++) {
+			end_addr   = phdr[n].p_vaddr + phdr[n].p_memsz;
+			start_addr = phdr[n + 1].p_vaddr;
+			TRACE("phdr[%d].start = %lx, phdr[%d].end = %lx, phdr[%d].start = %lx", n, phdr[n].p_vaddr, n,  end_addr, n + 1, start_addr);
+			ABORT_IF(start_addr >= phdr[n].p_vaddr && start_addr < end_addr, "invalid program headers");
+			if (end_addr > start_addr) {
+				TRACE("swap phdr[%d], phdr[%d]", n, n+1);
+				Elf64_Phdr tmp = phdr[n];
+				phdr[n] = phdr[n+1];
+				phdr[n + 1] = tmp;
+				swapped = true;
+				TRACE("swapped %d and %d", n, n + 1);
+			} else {
+				TRACE("skipping %d", n);
+			}
+		}
+		if (!swapped) {
+			break;
+		}
+	}
+}
+
 int main (int argc, const char** argv) {
 	TRACING_ENABLED = getenv("TANGRAM_TRACING") != NULL;
 
@@ -207,20 +238,22 @@ int main (int argc, const char** argv) {
 
 	// Compute the offset/size of the stub binary.
 	size_t stub_offs = headers.phdr 
-		? ALIGN(headers.offs + headers.sz, PAGE_SIZE)
-		: ALIGN(output.sz, PAGE_SIZE);
-	size_t stub_sz = ALIGN(stub_bin.sz, PAGE_SIZE);
+		? ALIGN(headers.offs + headers.sz, analysis.max_align)
+		: ALIGN(output.sz, analysis.max_align);
+	size_t stub_sz = ALIGN(stub_bin.sz, analysis.max_align);
 
 	// Create segment for the stub.
 	stub_segment->p_type   = PT_LOAD;
 	stub_segment->p_flags  = PF_R | PF_X;
-	stub_segment->p_align  = 0x1000;
+	stub_segment->p_align  = analysis.max_align;
 	stub_segment->p_offset = stub_offs;
-	stub_segment->p_paddr  = analysis.max_vaddr;
-	stub_segment->p_vaddr  = analysis.max_vaddr;
+	stub_segment->p_paddr  = ALIGN(analysis.max_vaddr, analysis.max_align);
+	stub_segment->p_vaddr  = ALIGN(analysis.max_vaddr, analysis.max_align);
 	stub_segment->p_filesz = stub_sz;
 	stub_segment->p_memsz  = stub_sz;
 
+	TRACE("new segment vaddr: %lx, memsz: %lx", stub_segment->p_vaddr, stub_segment->p_memsz);
+
 	// Create the footer.
 	Footer footer = {
 		.size = manifest.sz,
@@ -230,12 +263,26 @@ int main (int argc, const char** argv) {
 
 	// Update the entrypoint.
 	TRACE("%s entrypoint:%lx", stub_elf.path, stub_exe.ehdr->e_entry);
-	output_exe.ehdr->e_entry = analysis.max_vaddr + stub_exe.ehdr->e_entry;
+	output_exe.ehdr->e_entry = stub_segment->p_vaddr + stub_exe.ehdr->e_entry;
 
 	// Patch the program header table if necessary.
 	if (headers.phdr) {
 		output_exe.ehdr->e_phoff = headers.offs;
 		output_exe.ehdr->e_phnum = headers.num;
+	} else {
+		// Sort program headers.
+		Elf64_Phdr* start = NULL;
+		size_t num = 0;
+		for(int i = 0; i < output_exe.ehdr->e_phnum; i++) {
+			if (output_exe.phdr[i].p_type != PT_LOAD) {
+				continue;
+			}
+			if (!start) {
+				start = &output_exe.phdr[i];
+			}
+			num++;
+		}
+		elf_sort_segments(start, num);
 	}
 
 	// Close elf objects.

packages/std/packages/stub/src/stub2.c

@@ -1,12 +1,7 @@
-# This defines the entrypoint of the stub itself.
 .section .text.start,"ax",@progbits
 .global _start
 .type _start, @function
 _start:
-	# Clear the base pointer.
 	xor		%rbp, %rbp
-
-	# _stub_start(%rsp)
 	mov		%rsp, %rdi
-	call	_stub_start
-
+	call	main

packages/std/packages/stub/src/wrap.c

@@ -145,13 +145,18 @@ export const build = async (unresolved: tg.Unresolved<BuildArg>) => {
 
 			# Compile our sources
 			$CC_${tripleToEnvVar(target)}			\
-				${source}/stub/src/${arch}/start2.s	\
-				${source}/stub/src/stub2.c			\
+				${source}/stub/src/${arch}/start.s	\
+				${source}/stub/src/stub.c			\
+				${source}/stub/src/manifest.c		\
+				${source}/stub/src/manifest/json.c	\
+				${source}/stub/src/util.c			\
 				-I${source}/stub/include			\
 				-nostdlib							\
+				-nolibc								\
 				-ffreestanding						\
 				-fno-stack-protector				\
 				-static								\
+				-static-libgcc						\
 				-fno-asynchronous-unwind-tables		\
 				-fPIC								\
 				-Werror								\