(Hopefully) fixed AArch64 add and adds tests

Author: RealA10N

aarch64/isa/add.go

@@ -9,79 +9,59 @@ import (
 	"alon.kr/x/usm/gen"
 )
 
-type BaseAdd struct {
-	NonBranchingInstruction
+type Add struct {
+	gen.NonBranchingInstruction
 }
 
-func (BaseAdd) Operator() string {
-	return "add"
-}
-
-type AddReg struct {
-	BaseAdd
-	instructions.AddShiftedRegister
-}
-
-func (i AddReg) Generate(
-	*aarch64codegen.InstructionCodegenContext,
-) (instructions.Instruction, core.ResultList) {
-	return i, core.ResultList{}
-}
-
-type AddImm struct {
-	BaseAdd
-	instructions.AddImmediate
+func NewAddInstruction() gen.InstructionDefinition {
+	return Add{}
 }
 
-func (i AddImm) Generate(
-	*aarch64codegen.InstructionCodegenContext,
-) (instructions.Instruction, core.ResultList) {
-	return i, core.ResultList{}
+func (Add) Operator(*gen.InstructionInfo) string {
+	return "add"
 }
 
-type AddDefinition struct{}
-
-func (d AddDefinition) buildRegisterVariant(
+func (add Add) codegenRegisterVariant(
 	info *gen.InstructionInfo,
-) (gen.BaseInstruction, core.ResultList) {
+) (instructions.Instruction, core.ResultList) {
 	Xd, Xn, Xm, results := aarch64translation.BinaryInstructionToAarch64(info)
 	if !results.IsEmpty() {
 		return nil, results
 	}
 
-	return AddReg{
-		AddShiftedRegister: instructions.NewAddShiftedRegister(Xd, Xn, Xm),
-	}, core.ResultList{}
+	inst := instructions.NewAddShiftedRegister(Xd, Xn, Xm)
+	return inst, core.ResultList{}
 }
 
-func (AddDefinition) buildImmediateVariant(
+func (add Add) codegenImmediateVariant(
 	info *gen.InstructionInfo,
-) (gen.BaseInstruction, core.ResultList) {
+) (instructions.Instruction, core.ResultList) {
 	Xd, Xn, imm, results := aarch64translation.Immediate12InstructionToAarch64(info)
 	if !results.IsEmpty() {
 		return nil, results
 	}
 
-	return AddImm{
-		AddImmediate: instructions.NewAddImmediate(Xd, Xn, imm),
-	}, core.ResultList{}
+	inst := instructions.NewAddImmediate(Xd, Xn, imm)
+	return inst, core.ResultList{}
 }
 
-func (d AddDefinition) BuildInstruction(
-	info *gen.InstructionInfo,
-) (gen.BaseInstruction, core.ResultList) {
+func (add Add) Codegen(
+	ctx *aarch64codegen.InstructionCodegenContext,
+) (instructions.Instruction, core.ResultList) {
+	// TODO: this implementation is very similar to the one in adds.go, and possibly
+	// other binary arithmetic instructions. Consider refactoring this.
+
+	info := ctx.InstructionInfo
 	results := aarch64translation.ValidateBinaryInstruction(info)
 	if !results.IsEmpty() {
 		return nil, results
 	}
 
 	switch info.Arguments[1].(type) {
 	case *gen.RegisterArgumentInfo:
-		return d.buildRegisterVariant(info)
-
+		return add.codegenRegisterVariant(info)
 	case *gen.ImmediateInfo:
-		return d.buildImmediateVariant(info)
-
+		return add.codegenImmediateVariant(info)
 	default:
 		return nil, list.FromSingle(core.Result{
 			{
@@ -93,6 +73,13 @@ func (d AddDefinition) BuildInstruction(
 	}
 }
 
-func NewAddInstructionDefinition() gen.InstructionDefinition {
-	return AddDefinition{}
+func (add Add) Validate(
+	info *gen.InstructionInfo,
+) core.ResultList {
+	// TODO: this is a pretty hacky way to validate the instruction: we create
+	// a "mock" generation context, and then try to generate the binary
+	// representation of the instruction.
+	ctx := aarch64codegen.InstructionCodegenContext{InstructionInfo: info}
+	_, results := add.Codegen(&ctx)
+	return results
 }

aarch64/isa/add_test.go

@@ -39,15 +39,11 @@ func buildInstructionFromSource(
 		NewFunctionGenerationContext()
 
 	generator := gen.NewInstructionGenerator()
-	baseInfo, results := generator.Generate(ctx, node)
+	info, results := generator.Generate(ctx, node)
 	assert.True(t, results.IsEmpty())
-	assert.NotNil(t, baseInfo)
+	assert.NotNil(t, info)
 
-	baseInst, results := def.BuildInstruction(baseInfo)
-	assert.True(t, results.IsEmpty())
-	assert.NotNil(t, baseInst)
-
-	inst, ok := baseInst.(aarch64codegen.Instruction)
+	inst, ok := info.Instruction.(aarch64codegen.Instruction)
 	assert.True(t, ok)
 
 	return inst
@@ -62,14 +58,14 @@ func assertExpectedCodegen(
 	inst := buildInstructionFromSource(t, def, src)
 
 	generationContext := &aarch64codegen.InstructionCodegenContext{}
-	code, results := inst.Generate(generationContext)
+	code, results := inst.Codegen(generationContext)
 	assert.True(t, results.IsEmpty())
 
 	assert.Equal(t, expected.Binary(), code.Binary())
 }
 
 func TestAddExpectedCodegen(t *testing.T) {
-	def := aarch64isa.NewAddInstructionDefinition()
+	def := aarch64isa.NewAddInstruction()
 
 	testCases := []struct {
 		src      string

aarch64/isa/adds.go

@@ -25,7 +25,7 @@ func (adds Adds) codegenRegisterVariant(
 		return nil, results
 	}
 
-	inst := instructions.NewAddShiftedRegister(Xd, Xn, Xm)
+	inst := instructions.NewAddsShiftedRegister(Xd, Xn, Xm)
 	return inst, core.ResultList{}
 }
 
@@ -68,3 +68,14 @@ func (adds Adds) Codegen(
 		})
 	}
 }
+
+func (adds Adds) Validate(
+	info *gen.InstructionInfo,
+) core.ResultList {
+	// TODO: this is a pretty hacky way to validate the instruction: we create
+	// a "mock" generation context, and then try to generate the binary
+	// representation of the instruction.
+	ctx := aarch64codegen.InstructionCodegenContext{InstructionInfo: info}
+	_, results := adds.Codegen(&ctx)
+	return results
+}