all: merge dev.cc (a91c2e0d) into master

This change deletes the C implementations of
the Go compiler and assembler from the master branch.

The Go implementations are a bit slower right now,
due mainly to garbage generated by taking addresses
of stack variables all over the place (it was C code,
after all). That will be cleaned up (mechanically) over the
next week or so, and things will get faster.

Change-Id: I66b2b3477aec8835f9960d0798f5752dcd98d08f

.gitignore

@@ -26,15 +26,14 @@ misc/cgo/life/run.out
 misc/cgo/stdio/run.out
 misc/cgo/testso/main
 misc/dashboard/builder/builder
-src/cmd/?a/y.output
 src/liblink/anames?.c
-src/cmd/cc/y.output
+src/cmd/*/y.output
 src/cmd/cgo/zdefaultcc.go
 src/cmd/dist/dist.dSYM
 src/cmd/gc/mkbuiltin1
 src/cmd/gc/opnames.h
-src/cmd/gc/y.output
 src/cmd/go/zdefaultcc.go
+src/cmd/internal/obj/zbootstrap.go
 src/go/doc/headscan
 src/runtime/mkversion
 src/runtime/zaexperiment.h

doc/go1.5.txt

@@ -23,6 +23,7 @@ testing/quick: support generation of arrays (https://golang.org/cl/3865)
 
 Tools:
 
+cmd/go: std wildcard now excludes commands in main repo (https://golang.org/cl/5550)
 cmd/vet: better validation of struct tags (https://golang.org/cl/2685)
 cmd/ld: no longer record build timestamp in Windows PE file header (https://golang.org/cl/3740)
 
@@ -34,3 +35,21 @@ strconv: optimize decimal to string conversion (https://golang.org/cl/2105)
 math/big: faster assembly kernels for amd64 and 386 (https://golang.org/cl/2503, https://golang.org/cl/2560)
 math/big: faster "pure Go" kernels for platforms w/o assembly kernels (https://golang.org/cl/2480)
 
+Assembler:
+
+ARM assembly syntax has had some features removed.
+
+	- mentioning SP or PC as a hardware register
+		These are always pseudo-registers except that in some contexts
+		they're not, and it's confusing because the context should not affect
+		which register you mean. Change the references to the hardware
+		registers to be explicit: R13 for SP, R15 for PC.
+	- constant creation using assignment
+		The files say a=b when they could instead say #define a b.
+		There is no reason to have both mechanisms.
+	- R(0) to refer to R0.
+		Some macros use this to a great extent. Again, it's easy just to
+		use a #define to rename a register.
+	
+Also expression evaluation now uses uint64s instead of signed integers and the
+precedence of operators is now Go-like rather than C-like.

include/libc.h

@@ -292,6 +292,8 @@ extern	char*	getgoversion(void);
 extern	char*	getgoarm(void);
 extern	char*	getgo386(void);
 extern	char*	getgoextlinkenabled(void);
+extern	char*	getgohostos(void);
+extern	char*	getgohostarch(void);
 
 extern	char*	mktempdir(void);
 extern	void	removeall(char*);

include/link.h

@@ -241,6 +241,7 @@ struct	Prog
 	uchar	ft;	// oclass cache
 	uchar	tt;	// oclass cache
 	uchar	isize;	// amd64, 386
+	uchar	printed;
 
 	char	width;	/* fake for DATA */
 	char	mode;	/* 16, 32, or 64 in 6l, 8l; internal use in 5g, 6g, 8g */
@@ -303,6 +304,7 @@ struct	LSym
 	uchar	localentry;	// ppc64: instrs between global & local entry
 	uchar	seenglobl;
 	uchar	onlist;	// on the textp or datap lists
+	uchar	printed;
 	int16	symid;	// for writing .5/.6/.8 files
 	int32	dynid;
 	int32	sig;
@@ -458,6 +460,7 @@ struct	Hist
 	char*	name;
 	int32	line;
 	int32	offset;
+	uchar	printed;
 };
 
 struct	Plist

include/plan9/libc.h

@@ -14,6 +14,10 @@ char*	getgoversion(void);
 char*	getgoarm(void);
 char*	getgo386(void);
 char*	getgoextlinkenabled(void);
+char*	getgohostos(void);
+char*	getgohostarch(void);
+
+int	runcmd(char**);
 
 void	flagcount(char*, char*, int*);
 void	flagint32(char*, char*, int32*);

misc/cgo/test/issue9400/asm_arm.s

 #include "textflag.h"
 
 TEXT cas<>(SB),NOSPLIT,$0
-	MOVW	$0xffff0fc0, PC
+	MOVW	$0xffff0fc0, R15 // R15 is PC
 
 TEXT ·RewindAndSetgid(SB),NOSPLIT,$-4-0
 	// Save link register

misc/nacl/testzip.proto

@@ -10,9 +10,23 @@ usr	src=../misc/nacl/testdata
 go	src=..
 	src
 		cmd
+			asm
+				internal
+					asm
+						testdata
+							+
 			internal
 				objfile
 					objfile.go
+				rsc.io
+					arm
+						armasm
+							testdata
+								+
+					x86
+						x86asm
+							testdata
+								+
 			gofmt
 				gofmt.go
 				gofmt_test.go

src/cmd/5a/Makefile

-# Copyright 2012 The Go Authors.  All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-include ../../Make.dist
-
-install: y.tab.h
-
-y.tab.h: a.y
-	LANG=C LANGUAGE=en_US.UTF8 bison -d -v -y a.y

src/cmd/5a/a.h

-// Inferno utils/5a/a.h
-// http://code.google.com/p/inferno-os/source/browse/utils/5a/a.h
-//
-//	Copyright © 1994-1999 Lucent Technologies Inc.	All rights reserved.
-//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
-//	Portions Copyright © 1997-1999 Vita Nuova Limited
-//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
-//	Portions Copyright © 2004,2006 Bruce Ellis
-//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
-//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <bio.h>
-#include <link.h>
-#include "../5l/5.out.h"
-
-#ifndef	EXTERN
-#define	EXTERN	extern
-#endif
-
-#undef	getc
-#undef	ungetc
-#undef	BUFSIZ
-
-#define	getc	ccgetc
-#define	ungetc	ccungetc
-
-typedef	struct	Sym	Sym;
-typedef	struct	Io	Io;
-
-#define	MAXALIGN	7
-#define	FPCHIP		1
-#define	NSYMB		8192
-#define	BUFSIZ		8192
-#define	HISTSZ		20
-#ifndef	EOF
-#define	EOF		(-1)
-#endif
-#define	IGN		(-2)
-#define	GETC()		((--fi.c < 0)? filbuf(): *fi.p++ & 0xff)
-#define	NHASH		503
-#define	STRINGSZ	200
-#define	NMACRO		10
-
-struct	Sym
-{
-	Sym*	link;
-	char*	macro;
-	int32	value;
-	ushort	type;
-	char	*name;
-	char*	labelname;
-	char	sym;
-};
-#define	S	((Sym*)0)
-
-EXTERN	struct
-{
-	char*	p;
-	int	c;
-} fi;
-
-struct	Io
-{
-	Io*	link;
-	char	b[BUFSIZ];
-	char*	p;
-	short	c;
-	short	f;
-};
-#define	I	((Io*)0)
-
-enum
-{
-	CLAST,
-	CMACARG,
-	CMACRO,
-	CPREPROC,
-	
-	Always = C_SCOND_NONE,
-};
-
-EXTERN	int	debug[256];
-EXTERN	Sym*	hash[NHASH];
-EXTERN	char**	Dlist;
-EXTERN	int	nDlist;
-EXTERN	int	newflag;
-EXTERN	char*	hunk;
-EXTERN	char**	include;
-EXTERN	Io*	iofree;
-EXTERN	Io*	ionext;
-EXTERN	Io*	iostack;
-EXTERN	int32	lineno;
-EXTERN	int	nerrors;
-EXTERN	int32	nhunk;
-EXTERN	int	ninclude;
-EXTERN	int32	nsymb;
-EXTERN	Addr	nullgen;
-EXTERN	char*	outfile;
-EXTERN	int	pass;
-EXTERN	int32	pc;
-EXTERN	int	peekc;
-EXTERN	int32	stmtline;
-EXTERN	int	sym;
-EXTERN	char*	symb;
-EXTERN	int	thechar;
-EXTERN	char*	thestring;
-EXTERN	int32	thunk;
-EXTERN	Biobuf	obuf;
-EXTERN	Link*	ctxt;
-EXTERN	Biobuf	bstdout;
-EXTERN	Prog*	lastpc;
-
-void*	alloc(int32);
-void*	allocn(void*, int32, int32);
-void	ensuresymb(int32);
-void	errorexit(void);
-void	pushio(void);
-void	newio(void);
-void	newfile(char*, int);
-Sym*	slookup(char*);
-Sym*	lookup(void);
-Sym*	labellookup(Sym*);
-void	settext(LSym*);
-void	syminit(Sym*);
-int32	yylex(void);
-int	getc(void);
-int	getnsc(void);
-void	unget(int);
-int	escchar(int);
-void	cinit(void);
-void	pinit(char*);
-void	cclean(void);
-int	isreg(Addr*);
-void	outcode(int, int, Addr*, int, Addr*);
-int	filbuf(void);
-Sym*	getsym(void);
-void	domacro(void);
-void	macund(void);
-void	macdef(void);
-void	macexpand(Sym*, char*);
-void	macinc(void);
-void	maclin(void);
-void	macprag(void);
-void	macif(int);
-void	macend(void);
-void	dodefine(char*);
-void	prfile(int32);
-void	linehist(char*, int);
-void	gethunk(void);
-void	yyerror(char*, ...);
-int	yyparse(void);
-void	setinclude(char*);
-int	assemble(char*);
-void	listinit(void);

src/cmd/5a/lex.go

+// Inferno utils/5a/lex.c
+// http://code.google.com/p/inferno-os/source/browse/utils/5a/lex.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.	All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//go:generate go tool yacc a.y
+
+package main
+
+import (
+	"cmd/internal/asm"
+	"cmd/internal/obj"
+	"cmd/internal/obj/arm"
+)
+
+var (
+	yyerror  = asm.Yyerror
+	nullgen  obj.Addr
+	stmtline int32
+)
+
+const Always = arm.C_SCOND_NONE
+
+func main() {
+	cinit()
+
+	asm.LSCONST = LSCONST
+	asm.LCONST = LCONST
+	asm.LFCONST = LFCONST
+	asm.LNAME = LNAME
+	asm.LVAR = LVAR
+	asm.LLAB = LLAB
+
+	asm.Lexinit = lexinit
+	asm.Cclean = cclean
+	asm.Yyparse = yyparse
+
+	asm.Thechar = '5'
+	asm.Thestring = "arm"
+	asm.Thelinkarch = &arm.Linkarm
+
+	asm.Main()
+}
+
+type yy struct{}
+
+func (yy) Lex(v *yySymType) int {
+	var av asm.Yylval
+	tok := asm.Yylex(&av)
+	v.sym = av.Sym
+	v.lval = int32(av.Lval)
+	v.sval = av.Sval
+	v.dval = av.Dval
+	return tok
+}
+
+func (yy) Error(msg string) {
+	asm.Yyerror("%s", msg)
+}
+
+func yyparse() {
+	yyParse(yy{})
+}
+
+var lexinit = []asm.Lextab{
+	{"SP", LSP, obj.NAME_AUTO},
+	{"SB", LSB, obj.NAME_EXTERN},
+	{"FP", LFP, obj.NAME_PARAM},
+	{"PC", LPC, obj.TYPE_BRANCH},
+
+	{"R", LR, 0},
+
+	{"R0", LREG, arm.REG_R0},
+	{"R1", LREG, arm.REG_R1},
+	{"R2", LREG, arm.REG_R2},
+	{"R3", LREG, arm.REG_R3},
+	{"R4", LREG, arm.REG_R4},
+	{"R5", LREG, arm.REG_R5},
+	{"R6", LREG, arm.REG_R6},
+	{"R7", LREG, arm.REG_R7},
+	{"R8", LREG, arm.REG_R8},
+	{"R9", LREG, arm.REG_R9},
+	{"g", LREG, arm.REG_R10}, // avoid unintentionally clobber g using R10
+	{"R11", LREG, arm.REG_R11},
+	{"R12", LREG, arm.REG_R12},
+	{"R13", LREG, arm.REG_R13},
+	{"R14", LREG, arm.REG_R14},
+	{"R15", LREG, arm.REG_R15},
+	{"F", LF, 0},
+	{"F0", LFREG, arm.REG_F0},
+	{"F1", LFREG, arm.REG_F1},
+	{"F2", LFREG, arm.REG_F2},
+	{"F3", LFREG, arm.REG_F3},
+	{"F4", LFREG, arm.REG_F4},
+	{"F5", LFREG, arm.REG_F5},
+	{"F6", LFREG, arm.REG_F6},
+	{"F7", LFREG, arm.REG_F7},
+	{"F8", LFREG, arm.REG_F8},
+	{"F9", LFREG, arm.REG_F9},
+	{"F10", LFREG, arm.REG_F10},
+	{"F11", LFREG, arm.REG_F11},
+	{"F12", LFREG, arm.REG_F12},
+	{"F13", LFREG, arm.REG_F13},
+	{"F14", LFREG, arm.REG_F14},
+	{"F15", LFREG, arm.REG_F15},
+	{"C", LC, 0},
+	{"C0", LCREG, 0},
+	{"C1", LCREG, 1},
+	{"C2", LCREG, 2},
+	{"C3", LCREG, 3},
+	{"C4", LCREG, 4},
+	{"C5", LCREG, 5},
+	{"C6", LCREG, 6},
+	{"C7", LCREG, 7},
+	{"C8", LCREG, 8},
+	{"C9", LCREG, 9},
+	{"C10", LCREG, 10},
+	{"C11", LCREG, 11},
+	{"C12", LCREG, 12},
+	{"C13", LCREG, 13},
+	{"C14", LCREG, 14},
+	{"C15", LCREG, 15},
+	{"CPSR", LPSR, arm.REG_CPSR},
+	{"SPSR", LPSR, arm.REG_SPSR},
+	{"FPSR", LFCR, arm.REG_FPSR},
+	{"FPCR", LFCR, arm.REG_FPCR},
+	{".EQ", LCOND, arm.C_SCOND_EQ},
+	{".NE", LCOND, arm.C_SCOND_NE},
+	{".CS", LCOND, arm.C_SCOND_HS},
+	{".HS", LCOND, arm.C_SCOND_HS},
+	{".CC", LCOND, arm.C_SCOND_LO},
+	{".LO", LCOND, arm.C_SCOND_LO},
+	{".MI", LCOND, arm.C_SCOND_MI},
+	{".PL", LCOND, arm.C_SCOND_PL},
+	{".VS", LCOND, arm.C_SCOND_VS},
+	{".VC", LCOND, arm.C_SCOND_VC},
+	{".HI", LCOND, arm.C_SCOND_HI},
+	{".LS", LCOND, arm.C_SCOND_LS},
+	{".GE", LCOND, arm.C_SCOND_GE},
+	{".LT", LCOND, arm.C_SCOND_LT},
+	{".GT", LCOND, arm.C_SCOND_GT},
+	{".LE", LCOND, arm.C_SCOND_LE},
+	{".AL", LCOND, arm.C_SCOND_NONE},
+	{".U", LS, arm.C_UBIT},
+	{".S", LS, arm.C_SBIT},
+	{".W", LS, arm.C_WBIT},
+	{".P", LS, arm.C_PBIT},
+	{".PW", LS, arm.C_WBIT | arm.C_PBIT},
+	{".WP", LS, arm.C_WBIT | arm.C_PBIT},
+	{".F", LS, arm.C_FBIT},
+	{".IBW", LS, arm.C_WBIT | arm.C_PBIT | arm.C_UBIT},
+	{".IAW", LS, arm.C_WBIT | arm.C_UBIT},
+	{".DBW", LS, arm.C_WBIT | arm.C_PBIT},
+	{".DAW", LS, arm.C_WBIT},
+	{".IB", LS, arm.C_PBIT | arm.C_UBIT},
+	{".IA", LS, arm.C_UBIT},
+	{".DB", LS, arm.C_PBIT},
+	{".DA", LS, 0},
+	{"@", LAT, 0},
+	{"AND", LTYPE1, arm.AAND},
+	{"EOR", LTYPE1, arm.AEOR},
+	{"SUB", LTYPE1, arm.ASUB},
+	{"RSB", LTYPE1, arm.ARSB},
+	{"ADD", LTYPE1, arm.AADD},
+	{"ADC", LTYPE1, arm.AADC},
+	{"SBC", LTYPE1, arm.ASBC},
+	{"RSC", LTYPE1, arm.ARSC},
+	{"ORR", LTYPE1, arm.AORR},
+	{"BIC", LTYPE1, arm.ABIC},
+	{"SLL", LTYPE1, arm.ASLL},
+	{"SRL", LTYPE1, arm.ASRL},
+	{"SRA", LTYPE1, arm.ASRA},
+	{"MUL", LTYPE1, arm.AMUL},
+	{"MULA", LTYPEN, arm.AMULA},
+	{"DIV", LTYPE1, arm.ADIV},
+	{"MOD", LTYPE1, arm.AMOD},
+	{"MULL", LTYPEM, arm.AMULL},
+	{"MULAL", LTYPEM, arm.AMULAL},
+	{"MULLU", LTYPEM, arm.AMULLU},
+	{"MULALU", LTYPEM, arm.AMULALU},
+	{"MVN", LTYPE2, arm.AMVN}, /* op2 ignored */
+	{"MOVB", LTYPE3, arm.AMOVB},
+	{"MOVBU", LTYPE3, arm.AMOVBU},
+	{"MOVH", LTYPE3, arm.AMOVH},
+	{"MOVHU", LTYPE3, arm.AMOVHU},
+	{"MOVW", LTYPE3, arm.AMOVW},
+	{"MOVD", LTYPE3, arm.AMOVD},
+	{"MOVDF", LTYPE3, arm.AMOVDF},
+	{"MOVDW", LTYPE3, arm.AMOVDW},
+	{"MOVF", LTYPE3, arm.AMOVF},
+	{"MOVFD", LTYPE3, arm.AMOVFD},
+	{"MOVFW", LTYPE3, arm.AMOVFW},
+	{"MOVWD", LTYPE3, arm.AMOVWD},
+	{"MOVWF", LTYPE3, arm.AMOVWF},
+	{"LDREX", LTYPE3, arm.ALDREX},
+	{"LDREXD", LTYPE3, arm.ALDREXD},
+	{"STREX", LTYPE9, arm.ASTREX},
+	{"STREXD", LTYPE9, arm.ASTREXD},
+
+	/*
+		{"NEGF",		LTYPEI, ANEGF},
+		{"NEGD",		LTYPEI, ANEGD},
+		{"SQTF",		LTYPEI,	ASQTF},
+		{"SQTD",		LTYPEI,	ASQTD},
+		{"RNDF",		LTYPEI,	ARNDF},
+		{"RNDD",		LTYPEI,	ARNDD},
+		{"URDF",		LTYPEI,	AURDF},
+		{"URDD",		LTYPEI,	AURDD},
+		{"NRMF",		LTYPEI,	ANRMF},
+		{"NRMD",		LTYPEI,	ANRMD},
+	*/
+	{"ABSF", LTYPEI, arm.AABSF},
+	{"ABSD", LTYPEI, arm.AABSD},
+	{"SQRTF", LTYPEI, arm.ASQRTF},
+	{"SQRTD", LTYPEI, arm.ASQRTD},
+	{"CMPF", LTYPEL, arm.ACMPF},
+	{"CMPD", LTYPEL, arm.ACMPD},
+	{"ADDF", LTYPEK, arm.AADDF},
+	{"ADDD", LTYPEK, arm.AADDD},
+	{"SUBF", LTYPEK, arm.ASUBF},
+	{"SUBD", LTYPEK, arm.ASUBD},
+	{"MULF", LTYPEK, arm.AMULF},
+	{"MULD", LTYPEK, arm.AMULD},
+	{"DIVF", LTYPEK, arm.ADIVF},
+	{"DIVD", LTYPEK, arm.ADIVD},
+	{"B", LTYPE4, arm.AB},
+	{"BL", LTYPE4, arm.ABL},
+	{"BX", LTYPEBX, arm.ABX},
+	{"BEQ", LTYPE5, arm.ABEQ},
+	{"BNE", LTYPE5, arm.ABNE},
+	{"BCS", LTYPE5, arm.ABCS},
+	{"BHS", LTYPE5, arm.ABHS},
+	{"BCC", LTYPE5, arm.ABCC},
+	{"BLO", LTYPE5, arm.ABLO},
+	{"BMI", LTYPE5, arm.ABMI},
+	{"BPL", LTYPE5, arm.ABPL},
+	{"BVS", LTYPE5, arm.ABVS},
+	{"BVC", LTYPE5, arm.ABVC},
+	{"BHI", LTYPE5, arm.ABHI},
+	{"BLS", LTYPE5, arm.ABLS},
+	{"BGE", LTYPE5, arm.ABGE},
+	{"BLT", LTYPE5, arm.ABLT},
+	{"BGT", LTYPE5, arm.ABGT},
+	{"BLE", LTYPE5, arm.ABLE},
+	{"BCASE", LTYPE5, arm.ABCASE},
+	{"SWI", LTYPE6, arm.ASWI},
+	{"CMP", LTYPE7, arm.ACMP},
+	{"TST", LTYPE7, arm.ATST},
+	{"TEQ", LTYPE7, arm.ATEQ},
+	{"CMN", LTYPE7, arm.ACMN},
+	{"MOVM", LTYPE8, arm.AMOVM},
+	{"SWPBU", LTYPE9, arm.ASWPBU},
+	{"SWPW", LTYPE9, arm.ASWPW},
+	{"RET", LTYPEA, obj.ARET},
+	{"RFE", LTYPEA, arm.ARFE},
+	{"TEXT", LTYPEB, obj.ATEXT},
+	{"GLOBL", LGLOBL, obj.AGLOBL},
+	{"DATA", LTYPEC, obj.ADATA},
+	{"CASE", LTYPED, arm.ACASE},
+	{"END", LTYPEE, obj.AEND},
+	{"WORD", LTYPEH, arm.AWORD},
+	{"NOP", LTYPEI, obj.ANOP},
+	{"MCR", LTYPEJ, 0},
+	{"MRC", LTYPEJ, 1},
+	{"PLD", LTYPEPLD, arm.APLD},
+	{"UNDEF", LTYPEE, obj.AUNDEF},
+	{"CLZ", LTYPE2, arm.ACLZ},
+	{"MULWT", LTYPE1, arm.AMULWT},
+	{"MULWB", LTYPE1, arm.AMULWB},
+	{"MULAWT", LTYPEN, arm.AMULAWT},
+	{"MULAWB", LTYPEN, arm.AMULAWB},
+	{"USEFIELD", LTYPEN, obj.AUSEFIELD},
+	{"PCDATA", LTYPEPC, obj.APCDATA},
+	{"FUNCDATA", LTYPEF, obj.AFUNCDATA},
+}
+
+func cinit() {
+}
+
+func isreg(g *obj.Addr) bool {
+	return true
+}
+
+func cclean() {
+	outcode(obj.AEND, Always, &nullgen, 0, &nullgen)
+}
+
+var bcode = []int{
+	arm.ABEQ,
+	arm.ABNE,
+	arm.ABCS,
+	arm.ABCC,
+	arm.ABMI,
+	arm.ABPL,
+	arm.ABVS,
+	arm.ABVC,
+	arm.ABHI,
+	arm.ABLS,
+	arm.ABGE,
+	arm.ABLT,
+	arm.ABGT,
+	arm.ABLE,
+	arm.AB,
+	obj.ANOP,
+}
+
+var lastpc *obj.Prog
+
+func outcode(a, scond int32, g1 *obj.Addr, reg int32, g2 *obj.Addr) {
+	var p *obj.Prog
+	var pl *obj.Plist
+
+	/* hack to make B.NE etc. work: turn it into the corresponding conditional */
+	if a == arm.AB {
+		a = int32(bcode[(scond^arm.C_SCOND_XOR)&0xf])
+		scond = (scond &^ 0xf) | Always
+	}
+
+	if asm.Pass == 1 {
+		goto out
+	}
+
+	p = new(obj.Prog)
+	*p = obj.Prog{}
+	p.Ctxt = asm.Ctxt
+	p.As = int16(a)
+	p.Lineno = stmtline
+	p.Scond = uint8(scond)
+	p.From = *g1
+	p.Reg = int16(reg)
+	p.To = *g2
+	p.Pc = int64(asm.PC)
+
+	if lastpc == nil {
+		pl = obj.Linknewplist(asm.Ctxt)
+		pl.Firstpc = p
+	} else {
+		lastpc.Link = p
+	}
+	lastpc = p
+
+out:
+	if a != obj.AGLOBL && a != obj.ADATA {
+		asm.PC++
+	}
+}

src/cmd/5a/y.tab.h

-/* A Bison parser, made by GNU Bison 2.3.  */
-
-/* Skeleton interface for Bison's Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* Tokens.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-   /* Put the tokens into the symbol table, so that GDB and other debuggers
-      know about them.  */
-   enum yytokentype {
-     LTYPE1 = 258,
-     LTYPE2 = 259,
-     LTYPE3 = 260,
-     LTYPE4 = 261,
-     LTYPE5 = 262,
-     LTYPE6 = 263,
-     LTYPE7 = 264,
-     LTYPE8 = 265,
-     LTYPE9 = 266,
-     LTYPEA = 267,
-     LTYPEB = 268,
-     LGLOBL = 269,
-     LTYPEC = 270,
-     LTYPED = 271,
-     LTYPEE = 272,
-     LTYPEG = 273,
-     LTYPEH = 274,
-     LTYPEI = 275,
-     LTYPEJ = 276,
-     LTYPEK = 277,
-     LTYPEL = 278,
-     LTYPEM = 279,
-     LTYPEN = 280,
-     LTYPEBX = 281,
-     LTYPEPLD = 282,
-     LCONST = 283,
-     LSP = 284,
-     LSB = 285,
-     LFP = 286,
-     LPC = 287,
-     LTYPEX = 288,
-     LTYPEPC = 289,
-     LTYPEF = 290,
-     LR = 291,
-     LREG = 292,
-     LF = 293,
-     LFREG = 294,
-     LC = 295,
-     LCREG = 296,
-     LPSR = 297,
-     LFCR = 298,
-     LCOND = 299,
-     LS = 300,
-     LAT = 301,
-     LFCONST = 302,
-     LSCONST = 303,
-     LNAME = 304,
-     LLAB = 305,
-     LVAR = 306
-   };
-#endif
-/* Tokens.  */
-#define LTYPE1 258
-#define LTYPE2 259
-#define LTYPE3 260
-#define LTYPE4 261
-#define LTYPE5 262
-#define LTYPE6 263
-#define LTYPE7 264
-#define LTYPE8 265
-#define LTYPE9 266
-#define LTYPEA 267
-#define LTYPEB 268
-#define LGLOBL 269
-#define LTYPEC 270
-#define LTYPED 271
-#define LTYPEE 272
-#define LTYPEG 273
-#define LTYPEH 274
-#define LTYPEI 275
-#define LTYPEJ 276
-#define LTYPEK 277
-#define LTYPEL 278
-#define LTYPEM 279
-#define LTYPEN 280
-#define LTYPEBX 281
-#define LTYPEPLD 282
-#define LCONST 283
-#define LSP 284
-#define LSB 285
-#define LFP 286
-#define LPC 287
-#define LTYPEX 288
-#define LTYPEPC 289
-#define LTYPEF 290
-#define LR 291
-#define LREG 292
-#define LF 293
-#define LFREG 294
-#define LC 295
-#define LCREG 296
-#define LPSR 297
-#define LFCR 298
-#define LCOND 299
-#define LS 300
-#define LAT 301
-#define LFCONST 302
-#define LSCONST 303
-#define LNAME 304
-#define LLAB 305
-#define LVAR 306
-
-
-
-
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE
-#line 39 "a.y"
-{
-	Sym	*sym;
-	int32	lval;
-	double	dval;
-	char	sval[8];
-	Addr	addr;
-}
-/* Line 1529 of yacc.c.  */
-#line 159 "y.tab.h"
-	YYSTYPE;
-# define yystype YYSTYPE /* obsolescent; will be withdrawn */
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
-#endif
-
-extern YYSTYPE yylval;
-

src/cmd/5g/Makefile

-# Copyright 2012 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-include ../../Make.dist

src/cmd/5g/galign.c

-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <u.h>
-#include <libc.h>
-#include "gg.h"
-
-int	thechar	= '5';
-char*	thestring	= "arm";
-LinkArch*	thelinkarch = &linkarm;
-
-void
-linkarchinit(void)
-{
-}
-
-vlong MAXWIDTH = (1LL<<32) - 1;
-
-/*
- * go declares several platform-specific type aliases:
- * int, uint, float, and uintptr
- */
-Typedef	typedefs[] =
-{
-	{"int",		TINT,		TINT32},
-	{"uint",		TUINT,		TUINT32},
-	{"uintptr",	TUINTPTR,	TUINT32},
-	{0}
-};
-
-void
-betypeinit(void)
-{
-	widthptr = 4;
-	widthint = 4;
-	widthreg = 4;
-
-	listinit5();
-}
-
-void
-main(int argc, char **argv)
-{
-	thearch.thechar = thechar;
-	thearch.thestring = thestring;
-	thearch.thelinkarch = thelinkarch;
-	thearch.typedefs = typedefs;
-	thearch.REGSP = REGSP;
-	thearch.REGCTXT = REGCTXT;
-	thearch.MAXWIDTH = MAXWIDTH;
-	thearch.anyregalloc = anyregalloc;
-	thearch.betypeinit = betypeinit;
-	thearch.bgen = bgen;
-	thearch.cgen = cgen;
-	thearch.cgen_call = cgen_call;
-	thearch.cgen_callinter = cgen_callinter;
-	thearch.cgen_ret = cgen_ret;
-	thearch.clearfat = clearfat;
-	thearch.defframe = defframe;
-	thearch.excise = excise;
-	thearch.expandchecks = expandchecks;
-	thearch.gclean = gclean;
-	thearch.ginit = ginit;
-	thearch.gins = gins;
-	thearch.ginscall = ginscall;
-	thearch.igen = igen;
-	thearch.linkarchinit = linkarchinit;
-	thearch.peep = peep;
-	thearch.proginfo = proginfo;
-	thearch.regalloc = regalloc;
-	thearch.regfree = regfree;
-	thearch.regtyp = regtyp;
-	thearch.sameaddr = sameaddr;
-	thearch.smallindir = smallindir;
-	thearch.stackaddr = stackaddr;
-	thearch.excludedregs = excludedregs;
-	thearch.RtoB = RtoB;
-	thearch.FtoB = RtoB;
-	thearch.BtoR = BtoR;
-	thearch.BtoF = BtoF;
-	thearch.optoas = optoas;
-	thearch.doregbits = doregbits;
-	thearch.regnames = regnames;
-	
-	gcmain(argc, argv);
-}

src/cmd/5g/galign.go

+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"cmd/internal/obj"
+	"cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+var thechar int = '5'
+
+var thestring string = "arm"
+
+var thelinkarch *obj.LinkArch = &arm.Linkarm
+
+func linkarchinit() {
+}
+
+var MAXWIDTH int64 = (1 << 32) - 1
+
+/*
+ * go declares several platform-specific type aliases:
+ * int, uint, float, and uintptr
+ */
+var typedefs = []gc.Typedef{
+	gc.Typedef{"int", gc.TINT, gc.TINT32},
+	gc.Typedef{"uint", gc.TUINT, gc.TUINT32},
+	gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT32},
+}
+
+func betypeinit() {
+	gc.Widthptr = 4
+	gc.Widthint = 4
+	gc.Widthreg = 4
+
+}
+
+func main() {
+	gc.Thearch.Thechar = thechar
+	gc.Thearch.Thestring = thestring
+	gc.Thearch.Thelinkarch = thelinkarch
+	gc.Thearch.Typedefs = typedefs
+	gc.Thearch.REGSP = arm.REGSP
+	gc.Thearch.REGCTXT = arm.REGCTXT
+	gc.Thearch.MAXWIDTH = MAXWIDTH
+	gc.Thearch.Anyregalloc = anyregalloc
+	gc.Thearch.Betypeinit = betypeinit
+	gc.Thearch.Bgen = bgen
+	gc.Thearch.Cgen = cgen
+	gc.Thearch.Cgen_call = cgen_call
+	gc.Thearch.Cgen_callinter = cgen_callinter
+	gc.Thearch.Cgen_ret = cgen_ret
+	gc.Thearch.Clearfat = clearfat
+	gc.Thearch.Defframe = defframe
+	gc.Thearch.Excise = excise
+	gc.Thearch.Expandchecks = expandchecks
+	gc.Thearch.Gclean = gclean
+	gc.Thearch.Ginit = ginit
+	gc.Thearch.Gins = gins
+	gc.Thearch.Ginscall = ginscall
+	gc.Thearch.Igen = igen
+	gc.Thearch.Linkarchinit = linkarchinit
+	gc.Thearch.Peep = peep
+	gc.Thearch.Proginfo = proginfo
+	gc.Thearch.Regalloc = regalloc
+	gc.Thearch.Regfree = regfree
+	gc.Thearch.Regtyp = regtyp
+	gc.Thearch.Sameaddr = sameaddr
+	gc.Thearch.Smallindir = smallindir
+	gc.Thearch.Stackaddr = stackaddr
+	gc.Thearch.Excludedregs = excludedregs
+	gc.Thearch.RtoB = RtoB
+	gc.Thearch.FtoB = RtoB
+	gc.Thearch.BtoR = BtoR
+	gc.Thearch.BtoF = BtoF
+	gc.Thearch.Optoas = optoas
+	gc.Thearch.Doregbits = doregbits
+	gc.Thearch.Regnames = regnames
+
+	gc.Main()
+	gc.Exit(0)
+}

src/cmd/5a/doc.go → src/cmd/5g/gg.go

@@ -2,19 +2,31 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
+package main
 
-/*
+import "cmd/internal/obj/arm"
 
-5a is a version of the Plan 9 assembler.  The original is documented at
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
 
-	http://plan9.bell-labs.com/magic/man2html/1/8a
+const (
+	REGALLOC_R0   = arm.REG_R0
+	REGALLOC_RMAX = arm.REGEXT
+	REGALLOC_F0   = arm.REG_F0
+	REGALLOC_FMAX = arm.FREGEXT
+)
 
-Go-specific considerations are documented at
+var reg [REGALLOC_FMAX + 1]uint8
 
-	http://golang.org/doc/asm
+/*
+ * cgen
+ */
 
-Its target architecture is the ARM, referred to by these tools as arm.
+/*
+ * list.c
+ */
 
-*/
-package main
+/*
+ * reg.c
+ */

src/cmd/5g/gg.h

-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#ifndef	EXTERN
-#define	EXTERN	extern
-#endif
-
-#include "../gc/go.h"
-#include "../5l/5.out.h"
-
-enum
-{
-	REGALLOC_R0 = REG_R0,
-	REGALLOC_RMAX = REGEXT,
-	REGALLOC_F0 = REG_F0,
-	REGALLOC_FMAX = FREGEXT,
-};
-
-EXTERN	uchar	reg[REGALLOC_FMAX+1];
-extern	long	unmappedzero;
-
-/*
- * gen.c
- */
-void	compile(Node*);
-void	gen(Node*);
-Node*	lookdot(Node*, Node*, int);
-void	cgen_as(Node*, Node*);
-void	cgen_callmeth(Node*, int);
-void	cgen_callinter(Node*, Node*, int);
-void	cgen_proc(Node*, int);
-void	cgen_callret(Node*, Node*);
-void	cgen_dcl(Node*);
-int	needconvert(Type*, Type*);
-void	genconv(Type*, Type*);
-void	allocparams(void);
-void	checklabels(void);
-void	ginscall(Node*, int);
-
-/*
- * cgen
- */
-void	agen(Node*, Node*);
-Prog* cgenindex(Node *, Node *, int);
-void	igen(Node*, Node*, Node*);
-void agenr(Node *n, Node *a, Node *res);
-vlong	fieldoffset(Type*, Node*);
-void	sgen(Node*, Node*, int64);
-void	gmove(Node*, Node*);
-Prog*	gins(int, Node*, Node*);
-int	samaddr(Node*, Node*);
-void	raddr(Node *n, Prog *p);
-Prog*	gcmp(int, Node*, Node*);
-Prog*	gshift(int as, Node *lhs, int32 stype, int32 sval, Node *rhs);
-Prog *	gregshift(int as, Node *lhs, int32 stype, Node *reg, Node *rhs);
-void	naddr(Node*, Addr*, int);
-void	cgen_aret(Node*, Node*);
-void	cgen_hmul(Node*, Node*, Node*);
-void	cgen_shift(int, int, Node*, Node*, Node*);
-int	componentgen(Node*, Node*);
-
-/*
- * cgen64.c
- */
-void	cmp64(Node*, Node*, int, int, Prog*);
-void	cgen64(Node*, Node*);
-
-/*
- * gsubr.c
- */
-void	clearp(Prog*);
-Prog*	gbranch(int, Type*, int);
-Prog*	prog(int);
-void	gconv(int, int);
-int	conv2pt(Type*);
-vlong	convvtox(vlong, int);
-void	fnparam(Type*, int, int);
-Prog*	gop(int, Node*, Node*, Node*);
-int	optoas(int, Type*);
-void	ginit(void);
-void	gclean(void);
-void	regalloc(Node*, Type*, Node*);
-void	regfree(Node*);
-Node*	nodarg(Type*, int);
-void	nodreg(Node*, Type*, int);
-void	nodindreg(Node*, Type*, int);
-void	buildtxt(void);
-Plist*	newplist(void);
-int	isfat(Type*);
-int	dotaddable(Node*, Node*);
-void	sudoclean(void);
-int	sudoaddable(int, Node*, Addr*, int*);
-void	afunclit(Addr*, Node*);
-void	datagostring(Strlit*, Addr*);
-void	split64(Node*, Node*, Node*);
-void	splitclean(void);
-Node*	ncon(uint32 i);
-void	gtrack(Sym*);
-
-/*
- * obj.c
- */
-void	datastring(char*, int, Addr*);
-
-/*
- * list.c
- */
-void	listinit(void);
-
-void	zaddr(Biobuf*, Addr*, int, int);
-
-void afunclit(Addr*, Node*);
-int anyregalloc(void);
-void betypeinit(void);
-void bgen(Node*, int, int, Prog*);
-void cgen(Node*, Node*);
-void cgen_call(Node*, int);
-void cgen_callinter(Node*, Node*, int);
-void cgen_ret(Node*);
-void clearfat(Node*);
-void clearp(Prog*);
-void defframe(Prog*);
-int dgostringptr(Sym*, int, char*);
-int dgostrlitptr(Sym*, int, Strlit*);
-int dsname(Sym*, int, char*, int);
-int dsymptr(Sym*, int, Sym*, int);
-void dumpdata(void);
-void dumpit(char*, Flow*, int);
-void excise(Flow*);
-void expandchecks(Prog*);
-void fixautoused(Prog*);
-void gclean(void);
-void	gdata(Node*, Node*, int);
-void	gdatacomplex(Node*, Mpcplx*);
-void	gdatastring(Node*, Strlit*);
-void	ggloblnod(Node *nam);
-void	ggloblsym(Sym *s, int32 width, int8 flags);
-void ginit(void);
-Prog*	gins(int, Node*, Node*);
-void	ginscall(Node*, int);
-Prog*	gjmp(Prog*);
-void gtrack(Sym*);
-void	gused(Node*);
-void	igen(Node*, Node*, Node*);
-int isfat(Type*);
-void linkarchinit(void);
-void markautoused(Prog*);
-void naddr(Node*, Addr*, int);
-Plist* newplist(void);
-Node* nodarg(Type*, int);
-void patch(Prog*, Prog*);
-void proginfo(ProgInfo*, Prog*);
-void regalloc(Node*, Type*, Node*);
-void regfree(Node*);
-void regopt(Prog*);
-int regtyp(Addr*);
-int sameaddr(Addr*, Addr*);
-int smallindir(Addr*, Addr*);
-int stackaddr(Addr*);
-Prog* unpatch(Prog*);
-
-/*
- * reg.c
- */
-uint64 excludedregs(void);
-uint64 RtoB(int);
-uint64 FtoB(int);
-int BtoR(uint64);
-int BtoF(uint64);
-uint64 doregbits(int);
-char** regnames(int*);
-
-/*
- * peep.c
- */
-void peep(Prog*);

src/cmd/5g/prog.c

-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-#include <u.h>
-#include <libc.h>
-#include "gg.h"
-#include "../gc/popt.h"
-
-enum
-{
-	RightRdwr = RightRead | RightWrite,
-};
-
-// This table gives the basic information about instruction
-// generated by the compiler and processed in the optimizer.
-// See opt.h for bit definitions.
-//
-// Instructions not generated need not be listed.
-// As an exception to that rule, we typically write down all the
-// size variants of an operation even if we just use a subset.
-//
-// The table is formatted for 8-space tabs.
-static ProgInfo progtable[ALAST] = {
-	[ATYPE]=	{Pseudo | Skip},
-	[ATEXT]=	{Pseudo},
-	[AFUNCDATA]=	{Pseudo},
-	[APCDATA]=	{Pseudo},
-	[AUNDEF]=	{Break},
-	[AUSEFIELD]=	{OK},
-	[ACHECKNIL]=	{LeftRead},
-	[AVARDEF]=	{Pseudo | RightWrite},
-	[AVARKILL]=	{Pseudo | RightWrite},
-
-	// NOP is an internal no-op that also stands
-	// for USED and SET annotations, not the Intel opcode.
-	[ANOP]=		{LeftRead | RightWrite},
-	
-	// Integer.
-	[AADC]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AADD]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AAND]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ABIC]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ACMN]=		{SizeL | LeftRead | RightRead},
-	[ACMP]=		{SizeL | LeftRead | RightRead},
-	[ADIVU]=	{SizeL | LeftRead | RegRead | RightWrite},
-	[ADIV]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AEOR]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AMODU]=	{SizeL | LeftRead | RegRead | RightWrite},
-	[AMOD]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AMULALU]=	{SizeL | LeftRead | RegRead | RightRdwr},
-	[AMULAL]=	{SizeL | LeftRead | RegRead | RightRdwr},
-	[AMULA]=	{SizeL | LeftRead | RegRead | RightRdwr},
-	[AMULU]=	{SizeL | LeftRead | RegRead | RightWrite},
-	[AMUL]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[AMULL]=	{SizeL | LeftRead | RegRead | RightWrite},
-	[AMULLU]=	{SizeL | LeftRead | RegRead | RightWrite},
-	[AMVN]=		{SizeL | LeftRead | RightWrite},
-	[AORR]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ARSB]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ARSC]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ASBC]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ASLL]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ASRA]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ASRL]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ASUB]=		{SizeL | LeftRead | RegRead | RightWrite},
-	[ATEQ]=		{SizeL | LeftRead | RightRead},
-	[ATST]=		{SizeL | LeftRead | RightRead},
-
-	// Floating point.
-	[AADDD]=	{SizeD | LeftRead | RightRdwr},
-	[AADDF]=	{SizeF | LeftRead | RightRdwr},
-	[ACMPD]=	{SizeD | LeftRead | RightRead},
-	[ACMPF]=	{SizeF | LeftRead | RightRead},
-	[ADIVD]=	{SizeD | LeftRead | RightRdwr},
-	[ADIVF]=	{SizeF | LeftRead | RightRdwr},
-	[AMULD]=	{SizeD | LeftRead | RightRdwr},
-	[AMULF]=	{SizeF | LeftRead | RightRdwr},
-	[ASUBD]=	{SizeD | LeftRead | RightRdwr},
-	[ASUBF]=	{SizeF | LeftRead | RightRdwr},
-
-	// Conversions.
-	[AMOVWD]=		{SizeD | LeftRead | RightWrite | Conv},
-	[AMOVWF]=		{SizeF | LeftRead | RightWrite | Conv},
-	[AMOVDF]=		{SizeF | LeftRead | RightWrite | Conv},
-	[AMOVDW]=		{SizeL | LeftRead | RightWrite | Conv},
-	[AMOVFD]=		{SizeD | LeftRead | RightWrite | Conv},
-	[AMOVFW]=		{SizeL | LeftRead | RightWrite | Conv},
-
-	// Moves.
-	[AMOVB]=		{SizeB | LeftRead | RightWrite | Move},
-	[AMOVD]=		{SizeD | LeftRead | RightWrite | Move},
-	[AMOVF]=		{SizeF | LeftRead | RightWrite | Move},
-	[AMOVH]=		{SizeW | LeftRead | RightWrite | Move},
-	[AMOVW]=		{SizeL | LeftRead | RightWrite | Move},
-	// In addtion, duffzero reads R0,R1 and writes R1.  This fact is
-	// encoded in peep.c
-	[ADUFFZERO]=		{Call},
-	// In addtion, duffcopy reads R1,R2 and writes R0,R1,R2.  This fact is
-	// encoded in peep.c
-	[ADUFFCOPY]=		{Call},
-
-	// These should be split into the two different conversions instead
-	// of overloading the one.
-	[AMOVBS]=		{SizeB | LeftRead | RightWrite | Conv},
-	[AMOVBU]=		{SizeB | LeftRead | RightWrite | Conv},
-	[AMOVHS]=		{SizeW | LeftRead | RightWrite | Conv},
-	[AMOVHU]=		{SizeW | LeftRead | RightWrite | Conv},
-	
-	// Jumps.
-	[AB]=		{Jump | Break},
-	[ABL]=		{Call},
-	[ABEQ]=		{Cjmp},
-	[ABNE]=		{Cjmp},
-	[ABCS]=		{Cjmp},
-	[ABHS]=		{Cjmp},
-	[ABCC]=		{Cjmp},
-	[ABLO]=		{Cjmp},
-	[ABMI]=		{Cjmp},
-	[ABPL]=		{Cjmp},
-	[ABVS]=		{Cjmp},
-	[ABVC]=		{Cjmp},
-	[ABHI]=		{Cjmp},
-	[ABLS]=		{Cjmp},
-	[ABGE]=		{Cjmp},
-	[ABLT]=		{Cjmp},
-	[ABGT]=		{Cjmp},
-	[ABLE]=		{Cjmp},
-	[ARET]=		{Break},
-};
-
-void
-proginfo(ProgInfo *info, Prog *p)
-{
-	*info = progtable[p->as];
-	if(info->flags == 0)
-		fatal("unknown instruction %P", p);
-
-	if(p->from.type == TYPE_ADDR && p->from.sym != nil && (info->flags & LeftRead)) {
-		info->flags &= ~LeftRead;
-		info->flags |= LeftAddr;
-	}
-
-	if((info->flags & RegRead) && p->reg == 0) {
-		info->flags &= ~RegRead;
-		info->flags |= CanRegRead | RightRead;
-	}
-	
-	if(((p->scond & C_SCOND) != C_SCOND_NONE) && (info->flags & RightWrite))
-		info->flags |= RightRead;
-	
-	switch(p->as) {
-	case ADIV:
-	case ADIVU:
-	case AMOD:
-	case AMODU:
-		info->regset |= RtoB(REG_R12);
-		break;
-	}
-}

src/cmd/5g/prog.go

+// Copyright 2013 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"cmd/internal/obj"
+	"cmd/internal/obj/arm"
+)
+import "cmd/internal/gc"
+
+const (
+	RightRdwr = gc.RightRead | gc.RightWrite
+)
+
+// This table gives the basic information about instruction
+// generated by the compiler and processed in the optimizer.
+// See opt.h for bit definitions.
+//
+// Instructions not generated need not be listed.
+// As an exception to that rule, we typically write down all the
+// size variants of an operation even if we just use a subset.
+//
+// The table is formatted for 8-space tabs.
+var progtable = [arm.ALAST]gc.ProgInfo{
+	obj.ATYPE:     gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
+	obj.ATEXT:     gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+	obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+	obj.APCDATA:   gc.ProgInfo{gc.Pseudo, 0, 0, 0},
+	obj.AUNDEF:    gc.ProgInfo{gc.Break, 0, 0, 0},
+	obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0},
+	obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0},
+	obj.AVARDEF:   gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+	obj.AVARKILL:  gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0},
+
+	// NOP is an internal no-op that also stands
+	// for USED and SET annotations, not the Intel opcode.
+	obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+
+	// Integer.
+	arm.AADC:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AADD:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AAND:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ABIC:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ACMN:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+	arm.ACMP:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+	arm.ADIVU:   gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ADIV:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AEOR:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMODU:   gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMOD:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMULALU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+	arm.AMULAL:  gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+	arm.AMULA:   gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0},
+	arm.AMULU:   gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMUL:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMULL:   gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMULLU:  gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.AMVN:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite, 0, 0, 0},
+	arm.AORR:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ARSB:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ARSC:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ASBC:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ASLL:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ASRA:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ASRL:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ASUB:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0},
+	arm.ATEQ:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+	arm.ATST:    gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0},
+
+	// Floating point.
+	arm.AADDD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.AADDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.ACMPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+	arm.ACMPF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
+	arm.ADIVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.ADIVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.AMULD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.AMULF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.ASUBD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+	arm.ASUBF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+
+	// Conversions.
+	arm.AMOVWD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVWF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVDW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVFD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVFW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+
+	// Moves.
+	arm.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+	arm.AMOVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+	arm.AMOVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+	arm.AMOVH: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+	arm.AMOVW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+
+	// In addtion, duffzero reads R0,R1 and writes R1.  This fact is
+	// encoded in peep.c
+	obj.ADUFFZERO: gc.ProgInfo{gc.Call, 0, 0, 0},
+
+	// In addtion, duffcopy reads R1,R2 and writes R0,R1,R2.  This fact is
+	// encoded in peep.c
+	obj.ADUFFCOPY: gc.ProgInfo{gc.Call, 0, 0, 0},
+
+	// These should be split into the two different conversions instead
+	// of overloading the one.
+	arm.AMOVBS: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVBU: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVHS: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+	arm.AMOVHU: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+
+	// Jumps.
+	arm.AB:   gc.ProgInfo{gc.Jump | gc.Break, 0, 0, 0},
+	arm.ABL:  gc.ProgInfo{gc.Call, 0, 0, 0},
+	arm.ABEQ: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABNE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABCS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABHS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABCC: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABLO: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABMI: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABPL: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABVS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABVC: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABHI: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABLS: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABGE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABLT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABGT: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	arm.ABLE: gc.ProgInfo{gc.Cjmp, 0, 0, 0},
+	obj.ARET: gc.ProgInfo{gc.Break, 0, 0, 0},
+}
+
+func proginfo(info *gc.ProgInfo, p *obj.Prog) {
+	*info = progtable[p.As]
+	if info.Flags == 0 {
+		gc.Fatal("unknown instruction %v", p)
+	}
+
+	if p.From.Type == obj.TYPE_ADDR && p.From.Sym != nil && (info.Flags&gc.LeftRead != 0) {
+		info.Flags &^= gc.LeftRead
+		info.Flags |= gc.LeftAddr
+	}
+
+	if (info.Flags&gc.RegRead != 0) && p.Reg == 0 {
+		info.Flags &^= gc.RegRead
+		info.Flags |= gc.CanRegRead | gc.RightRead
+	}
+
+	if (p.Scond&arm.C_SCOND != arm.C_SCOND_NONE) && (info.Flags&gc.RightWrite != 0) {
+		info.Flags |= gc.RightRead
+	}
+
+	switch p.As {
+	case arm.ADIV,
+		arm.ADIVU,
+		arm.AMOD,
+		arm.AMODU:
+		info.Regset |= RtoB(arm.REG_R12)
+	}
+}

src/cmd/8g/doc.go → src/cmd/5g/util.go

-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2015 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
-/*
-
-8g is the version of the gc compiler for the x86.
-The $GOARCH for these tools is 386.
-
-It reads .go files and outputs .8 files. The flags are documented in ../gc/doc.go.
-
-*/
 package main
+
+func bool2int(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}

src/cmd/6a/Makefile

-# Copyright 2012 The Go Authors.  All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-include ../../Make.dist
-
-install: y.tab.h
-
-y.tab.h: a.y
-	LANG=C LANGUAGE=en_US.UTF8 bison -d -v -y a.y

src/cmd/6g/Makefile

-# Copyright 2012 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-include ../../Make.dist

src/cmd/5g/doc.go → src/cmd/6g/util.go

-// Copyright 2009 The Go Authors. All rights reserved.
+// Copyright 2015 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build ignore
-
-/*
-
-5g is the version of the gc compiler for the ARM.
-The $GOARCH for these tools is arm.
-
-It reads .go files and outputs .5 files. The flags are documented in ../gc/doc.go.
-
-*/
 package main
+
+func bool2int(b bool) int {
+	if b {
+		return 1
+	}
+	return 0
+}

src/cmd/8g/Makefile

-# Copyright 2012 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-include ../../Make.dist