ir: assign global IDs of unnamed global variables and functions

Fixes #148.

Author: mewmew

ir/func.go

@@ -9,7 +9,6 @@ import (
 	"github.com/llir/llvm/ir/constant"
 	"github.com/llir/llvm/ir/enum"
 	"github.com/llir/llvm/ir/types"
-	"github.com/llir/llvm/ir/value"
 	"github.com/pkg/errors"
 )
 
@@ -156,7 +155,7 @@ func (f *Func) AssignIDs() error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	id := int64(0)
-	setName := func(n local) error {
+	setName := func(n namedVar) error {
 		if n.IsUnnamed() {
 			if n.ID() != 0 && id != n.ID() {
 				want := id
@@ -180,7 +179,7 @@ func (f *Func) AssignIDs() error {
 			return errors.WithStack(err)
 		}
 		for _, inst := range block.Insts {
-			n, ok := inst.(local)
+			n, ok := inst.(namedVar)
 			if !ok {
 				continue
 			}
@@ -193,7 +192,7 @@ func (f *Func) AssignIDs() error {
 				return errors.WithStack(err)
 			}
 		}
-		n, ok := block.Term.(local)
+		n, ok := block.Term.(namedVar)
 		if !ok {
 			continue
 		}
@@ -304,14 +303,3 @@ func bodyString(body *Func) string {
 	buf.WriteString("}")
 	return buf.String()
 }
-
-// local is a local variable.
-type local interface {
-	value.Named
-	// ID returns the ID of the local identifier.
-	ID() int64
-	// SetID sets the ID of the local identifier.
-	SetID(id int64)
-	// IsUnnamed reports whether the local identifier is unnamed.
-	IsUnnamed() bool
-}

ir/global_test.go

@@ -0,0 +1,44 @@
+package ir_test
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/llir/llvm/ir"
+	"github.com/llir/llvm/ir/constant"
+	"github.com/llir/llvm/ir/types"
+)
+
+func TestAssignGlobalIDs(t *testing.T) {
+	// ref: https://github.com/llir/llvm/issues/148
+	const want = `@0 = global [15 x i8] c"Hello, world!\0A\00"
+@1 = global i32 0
+
+define i32 @2() {
+0:
+	ret i32 1
+}
+`
+
+	m := ir.NewModule()
+
+	// should be @0
+	s := "Hello, world!\n\x00"
+	i := constant.NewCharArrayFromString(s)
+	m.NewGlobalDef("", i)
+
+	// should be @1
+	i32 := types.I32
+	zero := constant.NewInt(i32, 0)
+	m.NewGlobalDef("", zero)
+
+	// should be @2
+	one := constant.NewInt(i32, 1)
+	m.NewFunc("", i32).NewBlock("").NewRet(one)
+
+	// Compare module output.
+	got := m.String()
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Errorf("module mismatch (-want +got):\n%s", diff)
+	}
+}

ir/helper.go

@@ -469,3 +469,14 @@ func (fw *fmtWriter) Fprintln(a ...interface{}) (n int, err error) {
 	fw.err = err
 	return n, err
 }
+
+// namedVar is a named variable.
+type namedVar interface {
+	value.Named
+	// ID returns the ID of the local identifier.
+	ID() int64
+	// SetID sets the ID of the local identifier.
+	SetID(id int64)
+	// IsUnnamed reports whether the local identifier is unnamed.
+	IsUnnamed() bool
+}

ir/module.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 
 	"github.com/llir/llvm/internal/enc"
 	"github.com/llir/llvm/internal/natsort"
@@ -52,6 +53,9 @@ type Module struct {
 	UseListOrders []*UseListOrder
 	// (optional) Basic block specific use-list order directives.
 	UseListOrderBBs []*UseListOrderBB
+
+	// mu prevents races on AssignGlobalIDs and AssignMetadataIDs.
+	mu sync.Mutex
 }
 
 // NewModule returns a new LLVM IR module.
@@ -75,6 +79,10 @@ func (m *Module) String() string {
 // syntax to w.
 func (m *Module) WriteTo(w io.Writer) (n int64, err error) {
 	fw := &fmtWriter{w: w}
+	// Assign global IDs.
+	if err := m.AssignGlobalIDs(); err != nil {
+		panic(fmt.Errorf("unable to assign globals IDs of module; %v", err))
+	}
 	// Assign metadata IDs.
 	if err := m.AssignMetadataIDs(); err != nil {
 		panic(fmt.Errorf("unable to assign metadata IDs of module; %v", err))
@@ -317,9 +325,55 @@ func (u *UseListOrderBB) String() string {
 
 // ### [ Helper functions ] ####################################################
 
+// AssignGlobalIDs assigns IDs to unnamed global variables.
+func (m *Module) AssignGlobalIDs() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	id := int64(0)
+	setName := func(n namedVar) error {
+		if n.IsUnnamed() {
+			if n.ID() != 0 && id != n.ID() {
+				want := id
+				got := n.ID()
+				return errors.Errorf("invalid global ID, expected %s, got %s", enc.GlobalID(want), enc.GlobalID(got))
+			}
+			n.SetID(id)
+			id++
+		}
+		return nil
+	}
+	// Assign global IDs to unnamed global variables.
+	for _, n := range m.Globals {
+		if err := setName(n); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+	// Assign global IDs to unnamed aliases.
+	for _, n := range m.Aliases {
+		if err := setName(n); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+	// Assign global IDs to unnamed IFuncs.
+	for _, n := range m.IFuncs {
+		if err := setName(n); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+	// Assign global IDs to unnamed functions.
+	for _, n := range m.Funcs {
+		if err := setName(n); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+	return nil
+}
+
 // AssignMetadataIDs assigns metadata IDs to the unnamed metadata definitions of
 // the module.
 func (m *Module) AssignMetadataIDs() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
 	// Index used IDs.
 	used := make(map[int64]bool)
 	for _, md := range m.MetadataDefs {