Merge pull request #244 from xushiwei/q

TypeSizes: goProgram

internal/build/build.go

@@ -88,15 +88,21 @@ const (
 )
 
 func Do(args []string, conf *Config) {
-	prog := llssa.NewProgram(nil)
-	sizes := prog.TypeSizes()
-
 	flags, patterns, verbose := ParseArgs(args, buildFlags)
 	cfg := &packages.Config{
 		Mode:       loadSyntax | packages.NeedDeps | packages.NeedModule | packages.NeedExportFile,
 		BuildFlags: flags,
 	}
 
+	llssa.Initialize(llssa.InitAll)
+	if verbose {
+		llssa.SetDebug(llssa.DbgFlagAll)
+		cl.SetDebug(cl.DbgFlagAll)
+	}
+
+	prog := llssa.NewProgram(nil)
+	sizes := prog.TypeSizes
+
 	if patterns == nil {
 		patterns = []string{"."}
 	}
@@ -117,12 +123,6 @@ func Do(args []string, conf *Config) {
 		return
 	}
 
-	llssa.Initialize(llssa.InitAll)
-	if verbose {
-		llssa.SetDebug(llssa.DbgFlagAll)
-		cl.SetDebug(cl.DbgFlagAll)
-	}
-
 	var needRt bool
 	var rt []*packages.Package
 	load := func() []*packages.Package {

internal/llgen/llgenf.go

@@ -43,7 +43,7 @@ func initRtAndPy(prog llssa.Program, cfg *packages.Config) {
 	load := func() []*packages.Package {
 		if pkgRtAndPy == nil {
 			var err error
-			pkgRtAndPy, err = packages.LoadEx(prog.TypeSizes(), cfg, llssa.PkgRuntime, llssa.PkgPython)
+			pkgRtAndPy, err = packages.LoadEx(prog.TypeSizes, cfg, llssa.PkgRuntime, llssa.PkgPython)
 			check(err)
 		}
 		return pkgRtAndPy
@@ -65,7 +65,7 @@ func GenFrom(fileOrPkg string) string {
 	cfg := &packages.Config{
 		Mode: loadSyntax | packages.NeedDeps,
 	}
-	initial, err := packages.LoadEx(prog.TypeSizes(), cfg, fileOrPkg)
+	initial, err := packages.LoadEx(prog.TypeSizes, cfg, fileOrPkg)
 	check(err)
 
 	_, pkgs := ssautil.AllPackages(initial, ssa.SanityCheckFunctions)

internal/packages/load.go

@@ -101,17 +101,14 @@ func refine(ld *loader, response *packages.DriverResponse) ([]*Package, error)
 // return an error. Clients may need to handle such errors before
 // proceeding with further analysis. The PrintErrors function is
 // provided for convenient display of all errors.
-func LoadEx(sizes types.Sizes, cfg *Config, patterns ...string) ([]*Package, error) {
+func LoadEx(sizes func(types.Sizes) types.Sizes, cfg *Config, patterns ...string) ([]*Package, error) {
 	ld := newLoader(cfg)
 	response, external, err := defaultDriver(&ld.Config, patterns...)
 	if err != nil {
 		return nil, err
 	}
 
-	if sizes == nil {
-		sizes = types.SizesFor(response.Compiler, response.Arch)
-	}
-	ld.sizes = sizes
+	ld.sizes = types.SizesFor(response.Compiler, response.Arch)
 	if ld.sizes == nil && ld.Config.Mode&(NeedTypes|NeedTypesSizes|NeedTypesInfo) != 0 {
 		// Type size information is needed but unavailable.
 		if external {
@@ -130,6 +127,9 @@ func LoadEx(sizes types.Sizes, cfg *Config, patterns ...string) ([]*Package, err
 		}
 	}
 
+	if sizes != nil {
+		ld.sizes = sizes(ld.sizes)
+	}
 	return refine(ld, response)
 }
 

ssa/package.go

@@ -101,6 +101,7 @@ func Initialize(flags InitFlags) {
 type aProgram struct {
 	ctx   llvm.Context
 	typs  typeutil.Map // rawType -> Type
+	sizes types.Sizes  // provided by Go compiler
 	gocvt goTypes
 
 	rt    *types.Package

ssa/type.go

@@ -74,6 +74,58 @@ func indexType(t types.Type) types.Type {
 
 // -----------------------------------------------------------------------------
 
+type goProgram aProgram
+
+// Alignof returns the alignment of a variable of type T.
+// Alignof must implement the alignment guarantees required by the spec.
+// The result must be >= 1.
+func (p *goProgram) Alignof(T types.Type) int64 {
+	return p.sizes.Alignof(T)
+}
+
+// Offsetsof returns the offsets of the given struct fields, in bytes.
+// Offsetsof must implement the offset guarantees required by the spec.
+// A negative entry in the result indicates that the struct is too large.
+func (p *goProgram) Offsetsof(fields []*types.Var) (ret []int64) {
+	prog := Program(p)
+	ptrSize := int64(prog.PointerSize())
+	extra := int64(0)
+	ret = p.sizes.Offsetsof(fields)
+	for i, f := range fields {
+		ret[i] += extra
+		extra += extraSize(f.Type(), ptrSize)
+	}
+	return
+}
+
+// Sizeof returns the size of a variable of type T.
+// Sizeof must implement the size guarantees required by the spec.
+// A negative result indicates that T is too large.
+func (p *goProgram) Sizeof(T types.Type) int64 {
+	prog := Program(p)
+	ptrSize := int64(prog.PointerSize())
+	return prog.sizes.Sizeof(T) + extraSize(T, ptrSize)
+}
+
+func extraSize(t types.Type, ptrSize int64) (ret int64) {
+	switch t := t.Underlying().(type) {
+	case *types.Signature:
+		return ptrSize
+	case *types.Struct:
+		n := t.NumFields()
+		for i := 0; i < n; i++ {
+			f := t.Field(i)
+			ret += extraSize(f.Type(), ptrSize)
+		}
+		return
+	case *types.Array:
+		return extraSize(t.Elem(), ptrSize) * t.Len()
+	}
+	return 0
+}
+
+// -----------------------------------------------------------------------------
+
 type rawType struct {
 	Type types.Type
 }
@@ -92,8 +144,9 @@ func (t Type) RawType() types.Type {
 }
 
 // TypeSizes returns the sizes of the types.
-func (p Program) TypeSizes() types.Sizes {
-	return nil // TODO(xsw)
+func (p Program) TypeSizes(sizes types.Sizes) types.Sizes {
+	p.sizes = sizes
+	return (*goProgram)(p)
 }
 
 // TODO(xsw):
@@ -117,10 +170,12 @@ func SizeOf(prog Program, t Type, n ...int64) Expr {
 	return prog.IntVal(size, prog.Uintptr())
 }
 
+/*
 func OffsetOf(prog Program, t Type, i int) Expr {
 	offset := prog.OffsetOf(t, i)
 	return prog.IntVal(offset, prog.Uintptr())
 }
+*/
 
 func (p Program) PointerSize() int {
 	return p.td.PointerSize()