Thanks to kaib for the tip.

R=ken2
CC=golang-dev
https://golang.org/cl/2596043

R=ken2
CC=golang-dev
https://golang.org/cl/2566042

value (through unsafe means) without having a reflect.Type
of type *interface{} (pointer to interface).  This is needed to make
gob able to handle interface values by a method analogous to
the way it handles maps.

R=rsc
CC=golang-dev
https://golang.org/cl/2597041

R=adg, r2
CC=golang-dev
https://golang.org/cl/2596041

Fixes #671.

R=adg, cw
CC=golang-dev
https://golang.org/cl/2431042

R=rsc
CC=golang-dev
https://golang.org/cl/2595041

R=brainman, vcc, Joe Poirier, rsc
CC=golang-dev
https://golang.org/cl/2530041

R=adg
CC=golang-dev
https://golang.org/cl/2470045

R=ken2
CC=golang-dev
https://golang.org/cl/2588041

That is, move the pc/ln table and the symbol table
into the read-only data segment.  This eliminates
the need for a special load command to map the
symbol table into memory, which makes the
information available on systems that couldn't handle
the magic load to 0x99000000, like NaCl and ARM QEMU
and Linux without config_highmem=y.  It also
eliminates an #ifdef and some clumsy code to
find the symbol table on Windows.

The bad news is that the binary appears to be bigger
than it used to be.  This is not actually the case, though:
the same amount of data is being mapped into memory
as before, and the tables are still read-only, so they're
still shared across multiple instances of the binary as
they were before.  The difference is just that the tables
aren't squirreled away in some section that "size" doesn't
know to look at.

This is a checkpoint.
It probably breaks Windows and breaks NaCl more
than it used to be broken, but those will be fixed.
The logic involving -s needs to be revisited too.

Fixes #871.

R=ken2
CC=golang-dev
https://golang.org/cl/2587041

Lay out code before data.

R=ken2
CC=golang-dev
https://golang.org/cl/2490043

R=rsc
CC=golang-dev
https://golang.org/cl/2512042

Fixes #1204.

R=golang-dev, brainman, Joe Poirier, alex.brainman, adg
CC=golang-dev, math-nuts
https://golang.org/cl/2532041

R=r, r2
CC=golang-dev
https://golang.org/cl/2543044

R=adg
CC=golang-dev
https://golang.org/cl/2486043

R=rsc, r2, r
CC=golang-dev
https://golang.org/cl/2550041

Fixes #1151.

R=rsc
CC=golang-dev
https://golang.org/cl/2469043

Adds func (z *Int) RandIntn(src rand.Source,n *Int) *Int

R=rsc
CC=golang-dev, gri
https://golang.org/cl/2315045

R=r, r2
CC=florian, golang-dev
https://golang.org/cl/2554042

R=ken2
CC=golang-dev
https://golang.org/cl/2473042

Missed a case, so now generalized.

R=ken2
CC=golang-dev
https://golang.org/cl/2540042

TBR=r
CC=golang-dev
https://golang.org/cl/2556041

No multiple processes/locks, managed to compile
and run a hello.go (with print not fmt).  Also test/sieve.go
seems to run until 439 and stops with a
'throw: all goroutines are asleep - deadlock!'
- just like runtime/tiny.

based on Russ's suggestions at:
http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612

Build instructions:
cd src/pkg/runtime
make clean && GOOS=plan9 make install
this will build and install the runtime.

When linking with 8l, you should pass -s to suppress symbol
generation in the a.out, otherwise the generated executable will not run.

This is runtime only, the porting of the toolchain has already
been done: http://code.google.com/p/go-plan9/source/browse
in the plan9-quanstro branch.

R=rsc
CC=golang-dev
https://golang.org/cl/2273041

R=ken2
CC=golang-dev
https://golang.org/cl/2555041

R=r, r2
CC=golang-dev
https://golang.org/cl/2506045

R=ken2
CC=golang-dev
https://golang.org/cl/2519044

R=ken2
CC=golang-dev
https://golang.org/cl/2479043

R=rsc
CC=golang-dev
https://golang.org/cl/2542042

R=rsc
CC=golang-dev
https://golang.org/cl/2543043

R=rsc, PeterGo
CC=golang-dev
https://golang.org/cl/2519043

Because the SB is only good for 8k and Go programs
tend to have much more data than that, SB doesn't
save very much.  A fmt.Printf-based hello world program
has  360 kB text segment.  Removing SB makes the text
500 bytes (0.14%) longer.

R=ken2, r2, ken3
CC=golang-dev
https://golang.org/cl/2487042

R=rsc, brainman
CC=golang-dev
https://golang.org/cl/2543042

R=ken2
CC=golang-dev
https://golang.org/cl/2481042

R=adg
CC=golang-dev
https://golang.org/cl/2521042

or at least gather more information

R=ken2
CC=golang-dev
https://golang.org/cl/2515042

R=rsc
CC=golang-dev
https://golang.org/cl/2519042

Also change the span-dependent jump algorithm
to use fewer iterations:

* resolve forward jumps at their targets (comefrom list)
* mark jumps as small or big and only do small->big
* record whether a jump failed to be encodable

These changes mean that a function with only small
jumps can be laid out in a single iteration, and the
vast majority of functions take just two iterations.
I was seeing a maximum of 5 iterations before; the
max now is 3 and there are fewer that get even that far.

R=ken2
CC=golang-dev
https://golang.org/cl/2537041

The old code said

	if(x) {
		handle a
		return
	}
	aa = *a
	rewrite aa to make x true
	recursivecall(&aa)

The new code says

	params = copy out of a
	if(!x) {
		rewrite params to make x true
	}
	handle params

but it's hard to see that in the Rietveld diffs because
it gets confused by changes in indentation.

Avoiding the recursion makes other changes easier.

R=ken2
CC=golang-dev
https://golang.org/cl/2533041

Using explicit relocations internally, we can
represent the data for a particular symbol as
an initialized block of memory instead of a
linked list of ADATA instructions.  The real
goal here is to be able to hand off some of the
relocations to the dynamic linker when interacting
with system libraries, but a pleasant side effect is
that the memory image is much more compact
than the ADATA list, so the linkers use less memory.

R=ken2
CC=golang-dev
https://golang.org/cl/2512041

R=r
CC=golang-dev
https://golang.org/cl/2526041