cmd: delete old[5689]a

These are the old assemblers written in C, and now they are
not needed.

Fixes #10510.

Change-Id: Id9337ffc8eccfd93c84b2e23f427fb1a576b543d
Reviewed-on: https://go-review.googlesource.com/12784Reviewed-by: Russ Cox <rsc@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

src/cmd/dist/buildtool.go

@@ -36,7 +36,6 @@ var bootstrapDirs = []string{
 	"compile/internal/gc",
 	"compile/internal/ppc64",
 	"compile/internal/x86",
-	"internal/asm",
 	"internal/gcprog",
 	"internal/obj",
 	"internal/obj/arm",
@@ -50,10 +49,6 @@ var bootstrapDirs = []string{
 	"link/internal/ld",
 	"link/internal/ppc64",
 	"link/internal/x86",
-	"old5a",
-	"old6a",
-	"old8a",
-	"old9a",
 }
 
 func bootstrapBuildTools() {

src/cmd/go/build.go

@@ -2180,11 +2180,6 @@ func (gcToolchain) gc(b *builder, p *Package, archive, obj string, asmhdr bool,
 	return ofile, output, err
 }
 
-// verifyAsm specifies whether to check the assemblers written in Go
-// against the assemblers written in C. If set, asm will run both asm and (say) 6a
-// and fail if the two produce different output files.
-const verifyAsm = true
-
 func (gcToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
 	// Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files.
 	inc := filepath.Join(goroot, "pkg", "include")
@@ -2193,31 +2188,12 @@ func (gcToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
 	if err := b.run(p.Dir, p.ImportPath, nil, args...); err != nil {
 		return err
 	}
-	// Disable checks when additional flags are passed, as the old assemblers
-	// don't implement some of them (e.g., -shared).
-	if verifyAsm && len(buildAsmflags) == 0 {
-		old := ""
-		switch goarch {
-		case "arm":
-			old = "old5a"
-		case "amd64", "amd64p32":
-			old = "old6a"
-		case "386":
-			old = "old8a"
-		case "ppc64", "ppc64le":
-			old = "old9a"
-		}
-		if old != "" {
-			if err := toolVerify(b, p, old, ofile, args); err != nil {
-				return err
-			}
-		}
-	}
 	return nil
 }
 
 // toolVerify checks that the command line args writes the same output file
 // if run using newTool instead.
+// Unused now but kept around for future use.
 func toolVerify(b *builder, p *Package, newTool string, ofile string, args []interface{}) error {
 	newArgs := make([]interface{}, len(args))
 	copy(newArgs, args)

src/cmd/go/pkg.go

@@ -646,10 +646,6 @@ var goTools = map[string]targetDir{
 	"cmd/newlink":                          toTool,
 	"cmd/nm":                               toTool,
 	"cmd/objdump":                          toTool,
-	"cmd/old5a":                            toTool,
-	"cmd/old6a":                            toTool,
-	"cmd/old8a":                            toTool,
-	"cmd/old9a":                            toTool,
 	"cmd/pack":                             toTool,
 	"cmd/pprof":                            toTool,
 	"cmd/trace":                            toTool,

src/cmd/old5a/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},
-	{"JMP", LTYPE4, arm.AB},
-	{"BL", LTYPE4, arm.ABL},
-	{"CALL", 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++
-	}
-}