cleanup

Author: m-hilgendorf

packages/std/sdk/proxy.tg.ts

@@ -272,15 +272,19 @@ const ldProxy = async (arg: LdProxyArg) => {
 	const host = arg.host ?? (await std.triple.host());
 	const build = arg.build ?? host;
 	const buildToolchain = arg.buildToolchain;
-	const embedWrapper = arg.embedWrapper ?? true;
+	const embedWrapper = arg.embedWrapper ?? std.triple.os(build) === "linux";
 
 	// Get the embedded wrapper artifacts.
-	const stubArtifacts = await stub.workspace(arg);
-	const wrapBin = await stubArtifacts.get("wrap");
-	const stubBin = await stubArtifacts.get("stub.bin");
-	const stubElf = await stubArtifacts.get("stub.elf");
-	
-	// Obtain wrapper components.
+	let wrapBin = undefined;
+	let stubBin = undefined;
+	let stubElf = undefined;
+
+	if (std.triple.os(build) === "linux") {
+		const stub_ = await stub.workspace(arg);
+		wrapBin = await stub_.get("wrap");
+		stubBin = await stub_.get("stub.bin");
+		stubElf = await stub_.get("stub.elf");
+	}
 
 	// The linker proxy is built for the build machine.
 	const buildLinkerProxy = await workspace.ldProxy({
@@ -313,9 +317,13 @@ const ldProxy = async (arg: LdProxyArg) => {
 			arg.interpreter ?? "none",
 		),
 		TANGRAM_WRAPPER_ID: tg.Mutation.setIfUnset(hostWrapper.id),
-		TANGRAM_STUB_BIN_ID: tg.Mutation.setIfUnset(stubBin.id),
-		TANGRAM_STUB_ELF_ID: tg.Mutation.setIfUnset(stubElf.id),
-		TANGRAM_WRAP_ID: tg.Mutation.setIfUnset(wrapBin.id),
+		TANGRAM_STUB_BIN_ID: stubBin
+			? tg.Mutation.setIfUnset(stubBin.id)
+			: undefined,
+		TANGRAM_STUB_ELF_ID: stubElf
+			? tg.Mutation.setIfUnset(stubElf.id)
+			: undefined,
+		TANGRAM_WRAP_ID: wrapBin ? tg.Mutation.setIfUnset(wrapBin.id) : undefined,
 		TANGRAM_LINKER_EMBED_WRAPPER: embedWrapper
 			? tg.Mutation.setIfUnset("true")
 			: undefined,

packages/std/wrap/stub.tg.ts

@@ -6,8 +6,8 @@ import * as ogWorkspace from "./workspace.tg.ts";
 import packages from "../packages" with { type: "directory" };
 
 type WorkspaceArg = {
-	build?: string;
 	host?: string;
+	target?: string;
 	release?: boolean;
 	source?: tg.Directory;
 	verbose?: boolean;
@@ -48,22 +48,27 @@ export const embedWrapper = async (arg: WrapArg) => {
 
 export const workspace = async (arg: WorkspaceArg) => {
 	const {
-		build: build_,
+		target: target_,
 		host: host_,
 		release = true,
 		source: source_,
 		verbose = false,
 	} = await tg.resolve(arg);
 	const host = host_ ?? (await std.triple.host());
-	const buildTriple = build_ ?? host;
+
+	// Ensure we're only building for Linux.
+	const target = target_ ?? host;
+
+	if (std.triple.os(target) !== "linux") {
+		throw new Error("embeded wrapper support is limited to linux targets");
+	}
 
 	// Get the source.
 	const source: tg.Directory = source_ ? source_ : packages;
 	return build({
-		// buildToolchain,
 		host,
 		verbose,
-		target: buildTriple,
+		target,
 		source,
 	}).then(tg.Directory.expect);
 };
@@ -249,11 +254,47 @@ export const testCompile = async () => {
 				}
 				return 0;
 			}	
-		`)
+		`),
 	});
 	return std.run`
 		gcc ${source}/main.c -o $OUTPUT
 	`
-	.bootstrap(true)
-	.env(toolchain, { utils: false }, { TANGRAM_TRACING: "true" });
-}
+		.bootstrap(true)
+		.env(
+			toolchain,
+			{ utils: false },
+			{
+				TANGRAM_TRACING: "true",
+				TANGRAM_LINKER_TRACING: "tangram_ld_proxy=trace",
+			},
+		);
+};
+
+export const testFull = async () => {
+	const toolchain = std.sdk();
+	const source = tg.directory({
+		"main.c": tg.file(`
+			#include <stdio.h>
+			extern char** environ;
+			int main(int argc, const char** argv) {
+				for (int i = 0; i < 2; i++) {
+					const char* var = i ? "envp" : "argv";
+					const char** s = i ? (const char**)environ : argv;
+					int j = 0;
+					for (; *s; s++, j++) {
+						printf("%s[%d] = %s\\n", var, j, *s);
+					}
+				}
+				return 0;
+			}	
+		`),
+	});
+	let file = std.$`
+		gcc ${source}/main.c -o $OUTPUT
+	`
+		.env(toolchain, { utils: false }, { TANGRAM_TRACING: "true" })
+		.then(tg.File.expect);
+	return std.wrap(file, {
+		env: { CUSTOM_ENV: "true", TANGRAM_SUPPRESS_ENV: "true" },
+	});
+};