ssa: global use elem type

ssa/abitype.go

@@ -354,7 +354,7 @@ func (b Builder) abiType(t types.Type) Expr {
 	if g == nil {
 		prog := b.Prog
 		g = pkg.doNewVar(name, prog.AbiTypePtrPtr())
-		g.Init(prog.Nil(g.Type))
+		g.InitNil()
 		if pub {
 			g.impl.SetLinkage(llvm.LinkOnceAnyLinkage)
 		}

ssa/decl.go

@@ -67,7 +67,7 @@ func (p Package) NewConst(name string, val constant.Value) NamedConst {
 
 type aGlobal struct {
 	Expr
-	array bool
+	//array bool
 }
 
 // A Global is a named Value holding the address of a package-level
@@ -92,17 +92,11 @@ func (p Package) NewVarEx(name string, t Type) Global {
 }
 
 func (p Package) doNewVar(name string, t Type) Global {
-	var gbl llvm.Value
-	var array bool
-	if t.kind == vkPtr && p.Prog.Elem(t).kind == vkArray { // TODO(xsw): check this code
-		typ := p.Prog.Elem(t).ll
-		gbl = llvm.AddGlobal(p.mod, typ, name)
-		gbl.SetInitializer(llvm.Undef(typ))
-		array = true
-	} else {
-		gbl = llvm.AddGlobal(p.mod, t.ll, name)
-	}
-	ret := &aGlobal{Expr{gbl, t}, array}
+	typ := p.Prog.Elem(t).ll
+	gbl := llvm.AddGlobal(p.mod, typ, name)
+	alignment := p.Prog.td.ABITypeAlignment(typ)
+	gbl.SetAlignment(alignment)
+	ret := &aGlobal{Expr{gbl, t}}
 	p.vars[name] = ret
 	return ret
 }
@@ -114,12 +108,13 @@ func (p Package) VarOf(name string) Global {
 
 // Init initializes the global variable with the given value.
 func (g Global) Init(v Expr) {
-	if g.array && v.kind == vkPtr { // TODO(xsw): check this code
-		return
-	}
 	g.impl.SetInitializer(v.impl)
 }
 
+func (g Global) InitNil() {
+	g.impl.SetInitializer(llvm.ConstNull(g.impl.GlobalValueType()))
+}
+
 // -----------------------------------------------------------------------------
 
 // Function represents the parameters, results, and code of a function

ssa/eh.go

@@ -102,8 +102,7 @@ func (p Package) keyInit(name string) {
 		return
 	}
 	prog := p.Prog
-	keyNil := prog.Nil(prog.CIntPtr())
-	keyVar.Init(keyNil)
+	keyVar.InitNil()
 	keyVar.impl.SetLinkage(llvm.LinkOnceAnyLinkage)
 
 	b := p.afterBuilder()

ssa/python.go

@@ -217,7 +217,7 @@ func (p Package) PyNewModVar(name string, doInit bool) Global {
 	objPtr := prog.PyObjectPtrPtr().raw.Type
 	g := p.NewVar(name, objPtr, InC)
 	if doInit {
-		g.Init(prog.Nil(g.Type))
+		g.InitNil()
 		g.impl.SetLinkage(llvm.LinkOnceAnyLinkage)
 	}
 	p.pymods[name] = g
@@ -372,7 +372,7 @@ func (p Package) PyNewFunc(name string, sig *types.Signature, doInit bool) PyObj
 	obj := p.NewVar(name, prog.PyObjectPtrPtr().RawType(), InC)
 	if doInit {
 		prog.NeedPyInit = true
-		obj.Init(prog.Nil(obj.Type))
+		obj.InitNil()
 		obj.impl.SetLinkage(llvm.LinkOnceAnyLinkage)
 	}
 	ty := &aType{obj.ll, rawType{types.NewPointer(sig)}, vkPyFuncRef}

ssa/ssa_test.go

@@ -189,19 +189,20 @@ func TestPyFunc(t *testing.T) {
 func TestVar(t *testing.T) {
 	prog := NewProgram(nil)
 	pkg := prog.NewPackage("bar", "foo/bar")
-	a := pkg.NewVar("a", types.Typ[types.Int], InGo)
-	if pkg.NewVar("a", types.Typ[types.Int], InGo) != a {
+	typ := types.NewPointer(types.Typ[types.Int])
+	a := pkg.NewVar("a", typ, InGo)
+	if pkg.NewVar("a", typ, InGo) != a {
 		t.Fatal("NewVar(a) failed")
 	}
-	pkg.NewVarEx("a", prog.Type(types.Typ[types.Int], InGo))
+	pkg.NewVarEx("a", prog.Type(typ, InGo))
 	a.Init(prog.Val(100))
-	b := pkg.NewVar("b", types.Typ[types.Int], InGo)
+	b := pkg.NewVar("b", typ, InGo)
 	b.Init(a.Expr)
 	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
 source_filename = "foo/bar"
 
-@a = global i64 100
-@b = global i64 @a
+@a = global i64 100, align 8
+@b = global i64 @a, align 8
 `)
 }
 
@@ -227,11 +228,11 @@ func TestStruct(t *testing.T) {
 
 	prog := NewProgram(nil)
 	pkg := prog.NewPackage("bar", "foo/bar")
-	pkg.NewVar("a", empty, InGo)
+	pkg.NewVar("a", types.NewPointer(empty), InGo)
 	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
 source_filename = "foo/bar"
 
-@a = external global {}
+@a = external global {}, align 1
 `)
 	if prog.NeedRuntime {
 		t.Fatal("NeedRuntime?")
@@ -244,7 +245,7 @@ func TestNamedStruct(t *testing.T) {
 
 	prog := NewProgram(nil)
 	pkg := prog.NewPackage("bar", "foo/bar")
-	pkg.NewVar("a", empty, InGo)
+	pkg.NewVar("a", types.NewPointer(empty), InGo)
 	if pkg.VarOf("a") == nil {
 		t.Fatal("VarOf failed")
 	}
@@ -253,7 +254,7 @@ source_filename = "foo/bar"
 
 %bar.Empty = type {}
 
-@a = external global %bar.Empty
+@a = external global %bar.Empty, align 1
 `)
 }
 
@@ -358,14 +359,14 @@ func TestFuncMultiRet(t *testing.T) {
 		types.NewVar(0, nil, "c", types.Typ[types.Int]),
 		types.NewVar(0, nil, "d", types.Typ[types.Float64]))
 	sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
-	a := pkg.NewVar("a", types.Typ[types.Int], InGo)
+	a := pkg.NewVar("a", types.NewPointer(types.Typ[types.Int]), InGo)
 	fn := pkg.NewFunc("fn", sig, InGo)
 	b := fn.MakeBody(1)
 	b.Return(a.Expr, fn.Param(0))
 	assertPkg(t, pkg, `; ModuleID = 'foo/bar'
 source_filename = "foo/bar"
 
-@a = external global i64
+@a = external global i64, align 8
 
 define { i64, double } @fn(double %0) {
 _llgo_0: