Now supports declaring explicit register type not on first sight

RealA10N · Feb 8, 2025 · e6dc264 · e6dc264
1 parent f644df5
commit e6dc264
Show file tree

Hide file tree

Showing 5 changed files with 53 additions and 15 deletions.
diff --git a/gen/function_generator.go b/gen/function_generator.go
@@ -16,6 +16,7 @@ type FunctionGenerator struct {
 	ParameterGenerator       FunctionContextGenerator[parse.ParameterNode, *RegisterInfo]
 	LabelDefinitionGenerator LabelContextGenerator[parse.LabelNode, *LabelInfo]
 	ReferencedTypeGenerator  FileContextGenerator[parse.TypeNode, ReferencedTypeInfo]
+	TargetGenerator          FunctionContextGenerator[parse.TargetNode, *TargetInfo]
 }
 
 func NewFunctionGenerator() FileContextGenerator[parse.FunctionNode, *FunctionInfo] {
@@ -25,6 +26,7 @@ func NewFunctionGenerator() FileContextGenerator[parse.FunctionNode, *FunctionIn
 			ParameterGenerator:       NewParameterGenerator(),
 			LabelDefinitionGenerator: NewLabelDefinitionGenerator(),
 			ReferencedTypeGenerator:  NewReferencedTypeGenerator(),
+			TargetGenerator:          NewTargetGenerator(),
 		},
 	)
 }
@@ -94,10 +96,31 @@ func (g *FunctionGenerator) collectLabelDefinitions(
 	return labelToInstructionIndex, results
 }
 
+// Before actually generating the instructions, we iterate over instruction and
+// only collect information about target registers.
+// Since USM requires all registers to be defined at least once with an explicit
+// type, after collecting all register definitions the register manager should
+// contain all registers with the required information.
+func (g *FunctionGenerator) collectRegisterDefinitions(
+	ctx *FunctionGenerationContext,
+	instructions []parse.InstructionNode,
+) (results core.ResultList) {
+	for _, instruction := range instructions {
+		for _, target := range instruction.Targets {
+			_, curResults := g.TargetGenerator.Generate(ctx, target)
+			results.Extend(&curResults)
+		}
+	}
+
+	return results
+}
+
 func (g *FunctionGenerator) generateInstructions(
 	ctx *FunctionGenerationContext,
 	instNodes []parse.InstructionNode,
 ) ([]*InstructionInfo, core.ResultList) {
+	g.collectRegisterDefinitions(ctx, instNodes)
+
 	instructions := make([]*InstructionInfo, 0, len(instNodes))
 
 	for _, instNode := range instNodes {

diff --git a/gen/function_generator_test.go b/gen/function_generator_test.go
@@ -156,3 +156,18 @@ func TestNoExplicitRegisterType(t *testing.T) {
 	details := results.Head.Value
 	assert.Contains(t, details[0].Message, "untyped register")
 }
+
+func TestExplicitRegisterDefinitionNotOnSecondSight(t *testing.T) {
+	src := `func @main {
+				%a = ADD $32 #0 $32 #0
+				$32 %a = ADD %a $32 #1
+				RET
+			}`
+	function, results := generateFunctionFromSource(t, src)
+	assert.True(t, results.IsEmpty())
+	assert.NotNil(t, function)
+
+	a := function.Registers.GetRegister("%a")
+	assert.NotNil(t, a)
+	assert.Equal(t, "$32", a.Type.String())
+}
diff --git a/gen/instruction_generator.go b/gen/instruction_generator.go
@@ -8,7 +8,7 @@ import (
 
 type InstructionGenerator struct {
 	ArgumentGenerator InstructionContextGenerator[parse.ArgumentNode, ArgumentInfo]
-	TargetGenerator   InstructionContextGenerator[parse.TargetNode, *TargetInfo]
+	TargetGenerator   FunctionContextGenerator[parse.TargetNode, *TargetInfo]
 }
 
 func NewInstructionGenerator() FunctionContextGenerator[
@@ -54,7 +54,10 @@ func (g *InstructionGenerator) generateTargets(
 
 	for i, target := range node.Targets {
 		v := target.View()
-		targetInfo, curResults := g.TargetGenerator.Generate(ctx, target)
+		targetInfo, curResults := g.TargetGenerator.Generate(
+			ctx.FunctionGenerationContext,
+			target,
+		)
 		results.Extend(&curResults)
 
 		if targetInfo.Register == nil {

diff --git a/gen/target_generator.go b/gen/target_generator.go
@@ -10,8 +10,8 @@ type TargetGenerator struct {
 	ReferencedTypeGenerator FileContextGenerator[parse.TypeNode, ReferencedTypeInfo]
 }
 
-func NewTargetGenerator() InstructionContextGenerator[parse.TargetNode, *TargetInfo] {
-	return InstructionContextGenerator[parse.TargetNode, *TargetInfo](
+func NewTargetGenerator() FunctionContextGenerator[parse.TargetNode, *TargetInfo] {
+	return FunctionContextGenerator[parse.TargetNode, *TargetInfo](
 		&TargetGenerator{
 			ReferencedTypeGenerator: NewReferencedTypeGenerator(),
 		},
@@ -42,7 +42,7 @@ func NewRegisterTypeMismatchResult(
 // If the targe node does not have an explicit type, and the register has not
 // been defined and processed yet, the generator will return nil.
 func (g *TargetGenerator) Generate(
-	ctx *InstructionGenerationContext,
+	ctx *FunctionGenerationContext,
 	node parse.TargetNode,
 ) (*TargetInfo, core.ResultList) {
 	registerName := nodeToSourceString(ctx.FileGenerationContext, node.Register)

diff --git a/gen/target_generator_test.go b/gen/target_generator_test.go
@@ -34,20 +34,17 @@ func TestTargetRegisterAlreadyDefined(t *testing.T) {
 		"%a": &gen.RegisterInfo{Name: "%a", Type: intTypeRef},
 	}
 
-	ctx := gen.InstructionGenerationContext{
-		FunctionGenerationContext: &gen.FunctionGenerationContext{
-			FileGenerationContext: &gen.FileGenerationContext{
-				GenerationContext: &testGenerationContext,
-				SourceContext:     src.Ctx(),
-				Types:             &types,
-			},
-			Registers: &registers,
+	ctx := &gen.FunctionGenerationContext{
+		FileGenerationContext: &gen.FileGenerationContext{
+			GenerationContext: &testGenerationContext,
+			SourceContext:     src.Ctx(),
+			Types:             &types,
 		},
-		InstructionInfo: gen.NewEmptyInstructionInfo(&unmanaged),
+		Registers: &registers,
 	}
 
 	generator := gen.NewTargetGenerator()
-	info, results := generator.Generate(&ctx, node)
+	info, results := generator.Generate(ctx, node)
 	assert.True(t, results.IsEmpty())
 	assert.Equal(t, intType, info.Register.Type.Base)
 }