Improved performance

src/build/compile.go

@@ -3,21 +3,19 @@ package build
 import (
 	"sync"
 
-	"git.akyoto.dev/cli/q/src/build/asm"
-	fail "git.akyoto.dev/cli/q/src/errors"
+	"git.akyoto.dev/cli/q/src/errors"
 )
 
 // compile waits for the scan to finish and compiles all functions.
-func compile(functions <-chan *Function, errors <-chan error) (Result, error) {
-	result := Result{
-		Unused: map[string]*Function{},
-	}
+func compile(functions <-chan *Function, errs <-chan error) (Result, error) {
+	result := Result{}
+	allFunctions := map[string]*Function{}
 
-	for functions != nil || errors != nil {
+	for functions != nil || errs != nil {
 		select {
-		case err, ok := <-errors:
+		case err, ok := <-errs:
 			if !ok {
-				errors = nil
+				errs = nil
 				continue
 			}
 
@@ -29,28 +27,28 @@ func compile(functions <-chan *Function, errors <-chan error) (Result, error) {
 				continue
 			}
 
-			result.Unused[function.Name] = function
+			allFunctions[function.Name] = function
 		}
 	}
 
-	compileFunctions(result.Unused)
+	compileFunctions(allFunctions)
 
-	for _, function := range result.Unused {
+	for _, function := range allFunctions {
 		if function.Error != nil {
 			return result, function.Error
 		}
+
+		result.InstructionCount += len(function.Assembler.Instructions)
 	}
 
-	main, exists := result.Unused["main"]
+	main, exists := allFunctions["main"]
 
 	if !exists {
-		return result, fail.MissingMainFunction
+		return result, errors.MissingMainFunction
 	}
 
-	result.Used = make([]*Function, 0, len(result.Unused))
-	result.markAlive(main)
-	result.findAliveCode(main)
-
+	result.Main = main
+	result.Functions = allFunctions
 	return result, nil
 }
 
@@ -69,29 +67,3 @@ func compileFunctions(functions map[string]*Function) {
 
 	wg.Wait()
 }
-
-// findAliveCode recursively finds all the calls to external functions and marks them as required.
-func (result *Result) findAliveCode(caller *Function) {
-	for _, x := range caller.Assembler.Instructions {
-		if x.Mnemonic != asm.CALL {
-			continue
-		}
-
-		name := x.Data.(*asm.Label).Name
-		callee, exists := result.Unused[name]
-
-		if !exists {
-			continue
-		}
-
-		result.markAlive(callee)
-		result.findAliveCode(callee)
-	}
-}
-
-// markAlive marks a function as being alive.
-func (result *Result) markAlive(f *Function) {
-	result.Used = append(result.Used, f)
-	result.InstructionCount += len(f.Assembler.Instructions)
-	delete(result.Unused, f.Name)
-}