diff --git a/go/ssa/builder.go b/go/ssa/builder.go
index b7e6441..4d53741 100644
--- a/go/ssa/builder.go
+++ b/go/ssa/builder.go
@@ -341,8 +341,10 @@
 			return blank{}
 		}
 		obj := fn.objectOf(e)
-		v := fn.Prog.packageLevelValue(obj) // var (address)
-		if v == nil {
+		var v Value
+		if g := fn.Prog.packageLevelMember(obj); g != nil {
+			v = g.(*Global) // var (address)
+		} else {
 			v = fn.lookup(obj, escaping)
 		}
 		return &address{addr: v, pos: e.Pos(), expr: e}
@@ -684,11 +686,11 @@
 			return nilConst(tv.Type)
 		}
 		// Package-level func or var?
-		if v := fn.Prog.packageLevelValue(obj); v != nil {
-			if _, ok := obj.(*types.Var); ok {
-				return emitLoad(fn, v) // var (address)
+		if v := fn.Prog.packageLevelMember(obj); v != nil {
+			if g, ok := v.(*Global); ok {
+				return emitLoad(fn, g) // var (address)
 			}
-			return v // (func)
+			return v.(*Function) // (func)
 		}
 		// Local var.
 		return emitLoad(fn, fn.lookup(obj, false)) // var (address)
@@ -2225,7 +2227,7 @@
 	if isBlankIdent(id) {
 		return // discard
 	}
-	fn := pkg.values[pkg.info.Defs[id]].(*Function)
+	fn := pkg.objects[pkg.info.Defs[id]].(*Function)
 	if decl.Recv == nil && id.Name == "init" {
 		var v Call
 		v.Call.Value = fn
@@ -2325,7 +2327,7 @@
 			// 1:1 initialization: var x, y = a(), b()
 			var lval lvalue
 			if v := varinit.Lhs[0]; v.Name() != "_" {
-				lval = &address{addr: p.values[v].(*Global), pos: v.Pos()}
+				lval = &address{addr: p.objects[v].(*Global), pos: v.Pos()}
 			} else {
 				lval = blank{}
 			}
@@ -2337,7 +2339,7 @@
 				if v.Name() == "_" {
 					continue
 				}
-				emitStore(init, p.values[v].(*Global), emitExtract(init, tuple, i), v.Pos())
+				emitStore(init, p.objects[v].(*Global), emitExtract(init, tuple, i), v.Pos())
 			}
 		}
 	}
diff --git a/go/ssa/create.go b/go/ssa/create.go
index a567a14..69cd937 100644
--- a/go/ssa/create.go
+++ b/go/ssa/create.go
@@ -65,7 +65,7 @@
 			Value:  NewConst(obj.Val(), obj.Type()),
 			pkg:    pkg,
 		}
-		pkg.values[obj] = c.Value
+		pkg.objects[obj] = c
 		pkg.Members[name] = c
 
 	case *types.Var:
@@ -76,7 +76,7 @@
 			typ:    types.NewPointer(obj.Type()), // address
 			pos:    obj.Pos(),
 		}
-		pkg.values[obj] = g
+		pkg.objects[obj] = g
 		pkg.Members[name] = g
 
 	case *types.Func:
@@ -99,7 +99,7 @@
 			fn.Synthetic = "loaded from gc object file"
 		}
 
-		pkg.values[obj] = fn
+		pkg.objects[obj] = fn
 		if sig.Recv() == nil {
 			pkg.Members[name] = fn // package-level function
 		}
@@ -166,7 +166,7 @@
 	p := &Package{
 		Prog:    prog,
 		Members: make(map[string]Member),
-		values:  make(map[types.Object]Value),
+		objects: make(map[types.Object]Member),
 		Pkg:     pkg,
 		info:    info,  // transient (CREATE and BUILD phases)
 		files:   files, // transient (CREATE and BUILD phases)
diff --git a/go/ssa/methods.go b/go/ssa/methods.go
index 9cf3839..22e1f3f 100644
--- a/go/ssa/methods.go
+++ b/go/ssa/methods.go
@@ -118,7 +118,7 @@
 // Panic ensues if there is none.
 //
 func (prog *Program) declaredFunc(obj *types.Func) *Function {
-	if v := prog.packageLevelValue(obj); v != nil {
+	if v := prog.packageLevelMember(obj); v != nil {
 		return v.(*Function)
 	}
 	panic("no concrete method: " + obj.String())
diff --git a/go/ssa/source.go b/go/ssa/source.go
index 8d9cca1..7e2a369 100644
--- a/go/ssa/source.go
+++ b/go/ssa/source.go
@@ -123,7 +123,7 @@
 				// Don't call Program.Method: avoid creating wrappers.
 				obj := mset.At(i).Obj().(*types.Func)
 				if obj.Pos() == pos {
-					return pkg.values[obj].(*Function)
+					return pkg.objects[obj].(*Function)
 				}
 			}
 		}
@@ -180,14 +180,14 @@
 	return prog.packages[obj]
 }
 
-// packageLevelValue returns the package-level value corresponding to
+// packageLevelMember returns the package-level member corresponding to
 // the specified named object, which may be a package-level const
-// (*Const), var (*Global) or func (*Function) of some package in
+// (*NamedConst), var (*Global) or func (*Function) of some package in
 // prog.  It returns nil if the object is not found.
 //
-func (prog *Program) packageLevelValue(obj types.Object) Value {
+func (prog *Program) packageLevelMember(obj types.Object) Member {
 	if pkg, ok := prog.packages[obj.Pkg()]; ok {
-		return pkg.values[obj]
+		return pkg.objects[obj]
 	}
 	return nil
 }
@@ -199,7 +199,7 @@
 // result's Signature, both in the params/results and in the receiver.
 //
 func (prog *Program) FuncValue(obj *types.Func) *Function {
-	fn, _ := prog.packageLevelValue(obj).(*Function)
+	fn, _ := prog.packageLevelMember(obj).(*Function)
 	return fn
 }
 
@@ -215,8 +215,8 @@
 		return NewConst(obj.Val(), obj.Type())
 	}
 	// Package-level named constant?
-	if v := prog.packageLevelValue(obj); v != nil {
-		return v.(*Const)
+	if v := prog.packageLevelMember(obj); v != nil {
+		return v.(*NamedConst).Value
 	}
 	return NewConst(obj.Val(), obj.Type())
 }
@@ -285,7 +285,7 @@
 	}
 
 	// Defining ident of package-level var?
-	if v := prog.packageLevelValue(obj); v != nil {
+	if v := prog.packageLevelMember(obj); v != nil {
 		return v.(*Global), true
 	}
 
diff --git a/go/ssa/ssa.go b/go/ssa/ssa.go
index e514e95..ea5b68e 100644
--- a/go/ssa/ssa.go
+++ b/go/ssa/ssa.go
@@ -45,12 +45,12 @@
 // and unspecified other things too.
 //
 type Package struct {
-	Prog    *Program               // the owning program
-	Pkg     *types.Package         // the corresponding go/types.Package
-	Members map[string]Member      // all package members keyed by name (incl. init and init#%d)
-	values  map[types.Object]Value // package members (incl. types and methods), keyed by object
-	init    *Function              // Func("init"); the package's init function
-	debug   bool                   // include full debug info in this package
+	Prog    *Program                // the owning program
+	Pkg     *types.Package          // the corresponding go/types.Package
+	Members map[string]Member       // all package members keyed by name (incl. init and init#%d)
+	objects map[types.Object]Member // mapping of package objects to members (incl. methods). Contains *NamedConst, *Global, *Function.
+	init    *Function               // Func("init"); the package's init function
+	debug   bool                    // include full debug info in this package
 
 	// The following fields are set transiently, then cleared
 	// after building.