ww: import toolchain — C bootstrap + ww-side self-host (phases 0-10)

C bootstrap (phases 0-9):
  cmd/wwc, cmd/6c, cmd/6a, cmd/6l, cmd/ww, rt, lib/*.

ww-side self-host (phase 10):
  selfhost/cmd/wwc — ww-cgen frontend; bootstrap fixed point.
  selfhost/cmd/6a  — assembler; byte-identical to C 6a (test 991).
  selfhost/cmd/6l  — linker w/ archive (.a) support; byte-identical
                     to C 6l (test 992).
  selfhost/cmd/ww  — driver (build/run/version); byte-identical to
                     C ww (test 993).

make test: 15/15. make bootstrap: ww2.s == ww3.s, ww2.o == ww3.o,
ww2 == ww3 byte-identical, with the full ww-tooled chain.

selfhost/cmd/6l/sym.ww

@@ -0,0 +1,75 @@
+// selfhost/cmd/6l/sym.ww — port of cmd/6l/sym.c.
+//
+// Linker symbol table. Singly-linked list, usually a few hundred
+// entries; hashing isn't worth it yet.
+
+use mem;
+
+type lsym = struct {
+	name:     str,
+	val:      u64,	// offset within combined .text once linked
+	defined:  i32,	// 1 if some lobj defines this symbol
+	owner:    *lobj,
+	idx_in_owner: i32,
+	snext:    *lsym,
+};
+
+type lrel = struct {
+	off:    u64,	// offset within combined .text
+	kind:   i32,	// R_X86_64_*
+	sym:    *lsym,
+	addend: i64,
+	rnext:  *lrel,
+};
+
+type lobj = struct {
+	path:      str,
+	buf:       *u8,	// object bytes
+	len:       u64,
+	text_off:  u64,	// offset of .text in combined output
+	text_size: u64,
+	onext:     *lobj,
+};
+
+type lnk = struct {
+	a:       *arena,
+	objs:    *lobj,
+	syms:    *lsym,
+	rels:    *lrel,
+	text:    *u8,	// combined .text
+	textcap: u64,
+	textlen: u64,
+	errs:    i32,
+};
+
+fn streq(a: str, b: str) bool = {
+	if (a.len != b.len) { return false; };
+	let i: i32 = 0;
+	for (i < a.len) {
+		if (a[i] != b[i]) { return false; };
+		i += 1;
+	};
+	return true;
+};
+
+export fn l_intern(l: *lnk, name: str) *lsym = {
+	let s: *lsym = l.syms;
+	for (s != nil) {
+		if (streq(s.name, name)) { return s; };
+		s = s.snext;
+	};
+	let n: *lsym = amalloc(l.a, 64u64): *lsym;
+	n.name = name;
+	n.snext = l.syms;
+	l.syms = n;
+	return n;
+};
+
+export fn l_lookup(l: *lnk, name: str) *lsym = {
+	let s: *lsym = l.syms;
+	for (s != nil) {
+		if (streq(s.name, name)) { return s; };
+		s = s.snext;
+	};
+	return nil;
+};