wip

Author: m-hilgendorf

packages/std/autotools/perl.tg.ts

@@ -77,7 +77,7 @@ export const build = async (arg?: tg.Unresolved<Arg>) => {
 	});
 
 	const unwrappedPerl = tg.File.expect(await perlArtifact.get("bin/perl"));
-
+	
 	const wrappedPerl = await std.wrap(unwrappedPerl, {
 		buildToolchain: env,
 		env: {

packages/std/packages/ld_proxy/src/main.rs

@@ -259,6 +259,7 @@ async fn create_wrapper(options: &Options) -> tg::Result<()> {
 		interpreter,
 		name,
 		needed_libraries: initial_needed_libraries,
+		entrypoint,
 	} = analyze_output_file(&options.output_path).await?;
 	tracing::debug!(?is_executable, ?interpreter, ?initial_needed_libraries);
 
@@ -446,12 +447,15 @@ async fn create_wrapper(options: &Options) -> tg::Result<()> {
 		let output_artifact_id = output_file.id().clone().into();
 
 		// Create the manifest.
-		let manifest =
+		let mut manifest =
 			create_manifest(output_artifact_id, options, interpreter, library_paths).await?;
 		tracing::trace!(?manifest);
 
 		// If requested, emebd the wrapper.
 		let new_wrapper = if options.embed {
+			if let Some(entrypoint) = entrypoint {
+				manifest.executable = tangram_std::manifest::Executable::Address(entrypoint);
+			}
 			manifest.embed(&tg, &output_file).await?
 		} else {
 			manifest.write(&tg).await?
@@ -736,6 +740,8 @@ struct AnalyzeOutputFileOutput {
 	name: Option<String>,
 	/// Does the output file specify libraries required at runtime?
 	needed_libraries: Vec<String>,
+	/// The entrypoint of the executable.
+	entrypoint: Option<u64>,
 }
 
 /// The possible interpreter requirements of an output file.
@@ -1262,6 +1268,7 @@ fn analyze_executable(bytes: &[u8]) -> tg::Result<AnalyzeOutputFileOutput> {
 			interpreter: InterpreterRequirement::None,
 			name: None,
 			needed_libraries: vec![],
+			entrypoint: None,
 		},
 
 		// Handle an ELF file.
@@ -1282,12 +1289,14 @@ fn analyze_executable(bytes: &[u8]) -> tg::Result<AnalyzeOutputFileOutput> {
 				.map(std::string::ToString::to_string)
 				.collect_vec();
 
+			let entrypoint = (elf.entry != 0).then_some(elf.entry);
+
 			// Check whether or not the object requires an interpreter:
 			// - If the object has an interpreter field.
 			// - If the object is a PIE and has 1 or more NEEDS.
 			let interpreter =
 				if elf.interpreter.is_some() || (is_pie && !needed_libraries.is_empty()) {
-					let interpreter = elf.interpreter.unwrap();
+					let interpreter = elf.interpreter.ok_or_else(|| tg::error!("missing interpreter in ELF"))?;
 					if interpreter.starts_with("/lib") {
 						if interpreter.contains("musl") {
 							InterpreterRequirement::Default(InterpreterFlavor::Musl)
@@ -1307,6 +1316,7 @@ fn analyze_executable(bytes: &[u8]) -> tg::Result<AnalyzeOutputFileOutput> {
 				interpreter,
 				name,
 				needed_libraries,
+				entrypoint,
 			}
 		},
 
@@ -1321,12 +1331,13 @@ fn analyze_executable(bytes: &[u8]) -> tg::Result<AnalyzeOutputFileOutput> {
 					.map(extract_filename)
 					.filter(|file_name| name.as_ref().is_none_or(|n| n != file_name))
 					.collect_vec();
-
+				let entrypoint = mach.entry;
 				AnalyzeOutputFileOutput {
 					is_executable,
 					interpreter: InterpreterRequirement::Default(InterpreterFlavor::Dyld),
 					name,
 					needed_libraries,
+					entrypoint: Some(entrypoint)
 				}
 			},
 			goblin::mach::Mach::Fat(mach) => {
@@ -1353,6 +1364,7 @@ fn analyze_executable(bytes: &[u8]) -> tg::Result<AnalyzeOutputFileOutput> {
 					interpreter: InterpreterRequirement::Default(InterpreterFlavor::Dyld),
 					name,
 					needed_libraries,
+					entrypoint: None
 				}
 			},
 		},

packages/std/packages/std/manifest.rs

@@ -316,7 +316,11 @@ impl Manifest {
 
 		// Create a temp file for the manifest.
 		let mut manifest = tempfile::NamedTempFile::new().map_err(|source| tg::error!(!source, "failed to get temp file"))?;
-		let output = "/tmp/__wrap_output__";
+
+		// Create a random output name.
+		let tempfile = tempfile::NamedTempFile::new()
+			.map_err(|source| tg::error!(!source, "failed to create temp file"))?;
+		let output = tempfile.path();
 
 		// Create the manifest file. TODO: asyncify.
 		let contents = serde_json::to_vec(self)

packages/std/packages/stub/include/manifest.h

@@ -176,10 +176,12 @@ static String render_ld_preload (Arena* arena, Manifest* manifest) {
 
 static void print_manifest (Manifest* manifest) {
 	if (manifest->executable.ptr) {
-		trace("executable: %s\n", manifest->executable);
+		trace("executable: ");
+		print_json_string(&manifest->executable);
+		trace("\n");
 	}
 	if (manifest->entrypoint) {
-		trace("entrypoint: %s\n", manifest->entrypoint);
+		trace("entrypoint: %d\n", manifest->entrypoint);
 	}
 	trace("interpreter: %s\n", manifest->interpreter.ptr);
 	trace("libary_paths:\n");

packages/std/packages/stub/include/table.h

@@ -77,15 +77,18 @@ static int insert (
 	while(node) {
 		// If this is an empty node, use it.
 		if (node->key.ptr == 0) {
-			node->key = key;
-			node->val = val;
+			node->key.ptr = key.ptr;
+			node->key.len = key.len;
+			node->val.ptr = val.ptr;
+			node->val.len = val.len;
 			table->size++;
 			return 0;
 		}
 
 		// If this has the same key, overwrite its value.
 		if (streq(node->key, key)) {
-			node->val = val;
+			node->val.ptr = val.ptr;
+			node->val.len = val.len;
 			return 0;
 		}
 		node = node->next;
@@ -96,8 +99,10 @@ static int insert (
 	if (!new_node) {
 		return -1;
 	}
-	new_node->key	= key;
-	new_node->val	= val;
+	new_node->key.ptr = key.ptr;
+	new_node->key.len = key.len;
+	new_node->val.ptr = val.ptr;
+	new_node->val.len = val.len;
 	new_node->next	= NULL;
 	node->next	= new_node;
 	table->size++;

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

@@ -134,6 +134,7 @@ static bool cstarts_with (String a, const char* prefix) {
 }
 
 static String join (Arena* arena, String separator, String* strings, size_t nstrings) {
+	// Compute the max length of the string.
 	size_t len = 0;
 	for (size_t n = 0; n < nstrings; n++) {
 		len += strings[n].len;
@@ -142,9 +143,11 @@ static String join (Arena* arena, String separator, String* strings, size_t nstr
 		}
 	}
 
+	// Allocate the new string.
 	String out = {0};
 	out.ptr = ALLOC_N(arena, len + 1, uint8_t);
 
+	// Append new strings to it.
 	for (size_t n = 0; n < nstrings; n++) {
 		if (strings[n].ptr) {
 			memcpy(out.ptr + out.len, strings[n].ptr, strings[n].len);