151 lines
3.8 KiB
Go
151 lines
3.8 KiB
Go
package generator
|
|
|
|
import "sort"
|
|
import "git.tebibyte.media/fspl/fspl/llvm"
|
|
import "git.tebibyte.media/fspl/fspl/entity"
|
|
import "git.tebibyte.media/fspl/fspl/analyzer"
|
|
|
|
type errNotFound string
|
|
func (err errNotFound) Error () string {
|
|
return string(err) + " not found"
|
|
}
|
|
|
|
// Target contains information about the machine the code is being written for.
|
|
type Target struct {
|
|
// WordSize is the size of the machine word. This determines the width
|
|
// of the Word type.
|
|
WordSize uint64
|
|
|
|
// Arch specifies the machine architecture. Values must correspond
|
|
// directly to those recognized by LLVM in a target triple.
|
|
Arch string
|
|
|
|
// OS specifies the machine operating system. Values must correspond
|
|
// directly to those recognized by LLVM in a target triple.
|
|
OS string
|
|
}
|
|
|
|
type generator struct {
|
|
target Target
|
|
tree analyzer.Tree
|
|
module *llvm.Module
|
|
|
|
types map[entity.Key] llvm.Type
|
|
functions map[entity.Key] *llvm.Function
|
|
|
|
managerStack []*blockManager
|
|
blockManager *blockManager
|
|
}
|
|
|
|
// Generate takes in a semantic tree and writes corresponding LLVM IR to the
|
|
// given io.Writer. It returns an error in case there is something wrong with
|
|
// the semantic tree that prevents the code generation process from occurring.
|
|
func (this Target) Generate (tree analyzer.Tree) (*llvm.Module, error) {
|
|
return (&generator {
|
|
module: new(llvm.Module),
|
|
target: this,
|
|
tree: tree,
|
|
types: make(map[entity.Key] llvm.Type),
|
|
functions: make(map[entity.Key] *llvm.Function),
|
|
}).generate()
|
|
}
|
|
|
|
func (this *generator) generate () (*llvm.Module, error) {
|
|
// generate functions
|
|
functions := sortKeyedMapKeys(this.tree.Functions)
|
|
for _, key := range functions {
|
|
_, err := this.function(key)
|
|
if err != nil { return nil, err }
|
|
}
|
|
|
|
// generate methods
|
|
types := sortKeyedMapKeys(this.tree.Types)
|
|
for _, key := range types {
|
|
ty := this.tree.Types[key]
|
|
methods := sortMapKeys(ty.Methods)
|
|
for _, methodName := range methods {
|
|
methodKey := key
|
|
methodKey.Method = methodName
|
|
_, err := this.method(methodKey)
|
|
if err != nil { return nil, err }
|
|
}
|
|
}
|
|
|
|
return this.module, nil
|
|
}
|
|
|
|
func (this *generator) typedef (key entity.Key) (llvm.Type, error) {
|
|
ty, exists := this.types[key]
|
|
if exists { return ty, nil }
|
|
|
|
def, exists := this.tree.Types[key]
|
|
if !exists {
|
|
return nil, errNotFound("typedef " + key.String())
|
|
}
|
|
return this.generateTypedef(def)
|
|
}
|
|
|
|
func (this *generator) method (key entity.Key) (*llvm.Function, error) {
|
|
method, exists := this.functions[key]
|
|
if exists { return method, nil }
|
|
|
|
ty, exists := this.tree.Types[key.StripMethod()]
|
|
if !exists {
|
|
return nil, errNotFound("owner of method " + key.String())
|
|
}
|
|
|
|
if method, exists := ty.Methods[key.Method]; exists {
|
|
return this.generateMethod(method)
|
|
}
|
|
return nil, errNotFound("method " + key.String())
|
|
}
|
|
|
|
func (this *generator) function (key entity.Key) (*llvm.Function, error) {
|
|
function, exists := this.functions[key]
|
|
if exists { return function, nil }
|
|
|
|
if function, exists := this.tree.Functions[key]; exists {
|
|
return this.generateFunction(function)
|
|
}
|
|
return nil, errNotFound("function " + key.String())
|
|
}
|
|
|
|
func sortMapKeys[T any] (unsorted map[string] T) []string {
|
|
keys := make([]string, len(unsorted))
|
|
index := 0
|
|
for key := range unsorted {
|
|
keys[index] = key
|
|
index ++
|
|
}
|
|
sort.Strings(keys)
|
|
return keys
|
|
}
|
|
|
|
type keySlice []entity.Key
|
|
|
|
func (keys keySlice) Len () int {
|
|
return len(keys)
|
|
}
|
|
|
|
func (keys keySlice) Less (lefti, righti int) bool {
|
|
left := keys[lefti]
|
|
right := keys[righti]
|
|
|
|
return left.String() < right.String()
|
|
}
|
|
|
|
func (keys keySlice) Swap (lefti, righti int) {
|
|
keys[lefti], keys[righti] = keys[righti], keys[lefti]
|
|
}
|
|
|
|
func sortKeyedMapKeys[T any] (unsorted map[entity.Key] T) keySlice {
|
|
keys := make(keySlice, len(unsorted))
|
|
index := 0
|
|
for key := range unsorted {
|
|
keys[index] = key
|
|
index ++
|
|
}
|
|
sort.Sort(keys)
|
|
return keys
|
|
}
|