auto name mangling provider about llvm HOT 4 CLOSED

type MangleModule struct {
	*ir.Module
	mangle func(name string) string
}

func (m *MangleModule) SetMangle(f func(string) string) {
	m.mangle = f
}

func (m *MangleModule) NewFunc(name string, retT types.Type, params ...*ir.Param) *ir.Func {
	return m.Module.NewFunc(m.mangle(name), retT, params...)
}
func (m *MangleModule) NewGlobal(name string, t types.Type) *ir.Global {
	return m.Module.NewGlobal(m.mangle(name), t)
}
func (m *MangleModule) NewGlobalDef(name string, init constant.Constant) *ir.Global {
	return m.Module.NewGlobalDef(m.mangle(name), init)
}
func (m *MangleModule) NewIFunc(name string, resolver constant.Constant) *ir.IFunc {
	return m.Module.NewIFunc(m.mangle(name), resolver)
}
func (m *MangleModule) New(name string, typ types.Type) types.Type {
	return m.Module.NewTypeDef(m.mangle(name), typ)
}

package main

import (
	"fmt"

	"github.com/llir/irutil"
	"github.com/llir/llvm/ir"
	"github.com/llir/llvm/ir/types"
)

func main() {
	m := ir.NewModule()
	// generate `float add(float x, float y)` function.
	genAddFloats(m)
	// generate `in add(in x, in y)` function.
	genAddInts(m)
	// print LLVM IR module to stdout.
	fmt.Println(m)
}

func genAddFloats(m *ir.Module) *ir.Func {
	// create function.
	f32 := types.Float
	x := ir.NewParam("x", f32)
	y := ir.NewParam("y", f32)
	const funcName = "add"
	f := m.NewFunc(funcName, f32, x, y)
	// mangle function name.
	f.SetName(irutil.MangleFuncName(funcName, f.Sig))
	// generate basic block with add and ret instructions.
	entry := f.NewBlock("entry")
	result := entry.NewFAdd(x, y)
	entry.NewRet(result)
	return f
}

func genAddInts(m *ir.Module) *ir.Func {
	// create function.
	i32 := types.I32
	x := ir.NewParam("x", i32)
	y := ir.NewParam("y", i32)
	const funcName = "add"
	f := m.NewFunc(funcName, i32, x, y)
	// mangle function name.
	f.SetName(irutil.MangleFuncName(funcName, f.Sig))
	// generate basic block with add and ret instructions.
	entry := f.NewBlock("entry")
	result := entry.NewAdd(x, y)
	entry.NewRet(result)
	return f
}

package irutil

import (
	"fmt"
	"strings"

	"github.com/llir/llvm/ir/types"
)

// MangleFuncName results the name mangled representation of the given function name,
// based on the specified function signature.
func MangleFuncName(funcName string, funcType *types.FuncType) string {
	buf := &strings.Builder{}
	const manglePrefix = "_Z"
	funcNameLen := len(funcName)
	fmt.Fprintf(buf, "%s%d%s", manglePrefix, funcNameLen, funcName)
	for _, paramType := range funcType.Params {
		paramTypeName := MangleParamType(paramType)
		buf.WriteString(paramTypeName)
	}
	return buf.String()
}

// MangleParamType results the name mangled representation of the given parameter type.
func MangleParamType(typ types.Type) string {
	switch typ := typ.(type) {
	case *types.IntType:
		switch typ.BitSize {
		case 32:
			return "i"
			// etc...
		}
	case *types.FloatType:
		switch typ.Kind {
		//case types.FloatKind... etc
		case types.FloatKindFloat:
			return "f"
		}
		// etc...
	}
	panic(fmt.Errorf("support for mangling parameter type %v not yet implemented", typ))
}

package main

import (
	"fmt"

	"github.com/llir/llvm/ir"
	"github.com/llir/llvm/ir/types"
)

func main() {
	m := ir.NewModule()
	a32 := m.NewGlobal("a", types.I32)
	a64 := m.NewGlobal("a", types.I64)
	_ = a32
	_ = a64
	fmt.Println(m)
}