| // Copyright 2009 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| // Annotate Crefs in Prog with C types by parsing gcc debug output. | |
| // Conversion of debug output to Go types. | |
| package main | |
| import ( | |
| "bytes" | |
| "debug/dwarf" | |
| "debug/elf" | |
| "debug/macho" | |
| "fmt" | |
| "go/ast" | |
| "go/parser" | |
| "go/token" | |
| "os" | |
| "strconv" | |
| "strings" | |
| ) | |
| func (p *Prog) loadDebugInfo() { | |
| var b bytes.Buffer | |
| b.WriteString(p.Preamble) | |
| stdout := p.gccPostProc(b.Bytes()) | |
| defines := make(map[string]string) | |
| for _, line := range strings.Split(stdout, "\n", 0) { | |
| if len(line) < 9 || line[0:7] != "#define" { | |
| continue | |
| } | |
| line = strings.TrimSpace(line[8:]) | |
| var key, val string | |
| spaceIndex := strings.Index(line, " ") | |
| tabIndex := strings.Index(line, "\t") | |
| if spaceIndex == -1 && tabIndex == -1 { | |
| continue | |
| } else if tabIndex == -1 || (spaceIndex != -1 && spaceIndex < tabIndex) { | |
| key = line[0:spaceIndex] | |
| val = strings.TrimSpace(line[spaceIndex:]) | |
| } else { | |
| key = line[0:tabIndex] | |
| val = strings.TrimSpace(line[tabIndex:]) | |
| } | |
| // Only allow string, character, and numeric constants. Ignoring #defines for | |
| // symbols allows those symbols to be referenced in Go, as they will be | |
| // translated by gcc later. | |
| _, err := strconv.Atoi(string(val[0])) | |
| if err == nil || val[0] == '\'' || val[0] == '"' { | |
| defines[key] = val | |
| } | |
| } | |
| // Construct a slice of unique names from p.Crefs. | |
| m := make(map[string]int) | |
| for _, c := range p.Crefs { | |
| // If we've already found this name as a define, it is not a Cref. | |
| if val, ok := defines[c.Name]; ok { | |
| _, err := parser.ParseExpr("", val, nil) | |
| if err != nil { | |
| fmt.Fprintf(os.Stderr, "The value in C.%s does not parse as a Go expression; cannot use.\n", c.Name) | |
| os.Exit(2) | |
| } | |
| c.Context = "const" | |
| c.TypeName = false | |
| p.Constdef[c.Name] = val | |
| continue | |
| } | |
| m[c.Name] = -1 | |
| } | |
| names := make([]string, 0, len(m)) | |
| for name, _ := range m { | |
| i := len(names) | |
| names = names[0 : i+1] | |
| names[i] = name | |
| m[name] = i | |
| } | |
| // Coerce gcc into telling us whether each name is | |
| // a type, a value, or undeclared. We compile a function | |
| // containing the line: | |
| // name; | |
| // If name is a type, gcc will print: | |
| // x.c:2: warning: useless type name in empty declaration | |
| // If name is a value, gcc will print | |
| // x.c:2: warning: statement with no effect | |
| // If name is undeclared, gcc will print | |
| // x.c:2: error: 'name' undeclared (first use in this function) | |
| // A line number directive causes the line number to | |
| // correspond to the index in the names array. | |
| b.Reset() | |
| b.WriteString(p.Preamble) | |
| b.WriteString("void f(void) {\n") | |
| b.WriteString("#line 0 \"cgo-test\"\n") | |
| for _, n := range names { | |
| b.WriteString(n) | |
| b.WriteString(";\n") | |
| } | |
| b.WriteString("}\n") | |
| kind := make(map[string]string) | |
| _, stderr := p.gccDebug(b.Bytes()) | |
| if stderr == "" { | |
| fatal("gcc produced no output") | |
| } | |
| for _, line := range strings.Split(stderr, "\n", 0) { | |
| if len(line) < 9 || line[0:9] != "cgo-test:" { | |
| continue | |
| } | |
| line = line[9:] | |
| colon := strings.Index(line, ":") | |
| if colon < 0 { | |
| continue | |
| } | |
| i, err := strconv.Atoi(line[0:colon]) | |
| if err != nil { | |
| continue | |
| } | |
| what := "" | |
| switch { | |
| default: | |
| continue | |
| case strings.Index(line, ": useless type name in empty declaration") >= 0: | |
| what = "type" | |
| case strings.Index(line, ": statement with no effect") >= 0: | |
| what = "value" | |
| case strings.Index(line, "undeclared") >= 0: | |
| what = "error" | |
| } | |
| if old, ok := kind[names[i]]; ok && old != what { | |
| error(noPos, "inconsistent gcc output about C.%s", names[i]) | |
| } | |
| kind[names[i]] = what | |
| } | |
| for _, n := range names { | |
| if _, ok := kind[n]; !ok { | |
| error(noPos, "could not determine kind of name for C.%s", n) | |
| } | |
| } | |
| if nerrors > 0 { | |
| fatal("failed to interpret gcc output:\n%s", stderr) | |
| } | |
| // Extract the types from the DWARF section of an object | |
| // from a well-formed C program. Gcc only generates DWARF info | |
| // for symbols in the object file, so it is not enough to print the | |
| // preamble and hope the symbols we care about will be there. | |
| // Instead, emit | |
| // typeof(names[i]) *__cgo__i; | |
| // for each entry in names and then dereference the type we | |
| // learn for __cgo__i. | |
| b.Reset() | |
| b.WriteString(p.Preamble) | |
| for i, n := range names { | |
| fmt.Fprintf(&b, "typeof(%s) *__cgo__%d;\n", n, i) | |
| } | |
| d, stderr := p.gccDebug(b.Bytes()) | |
| if d == nil { | |
| fatal("gcc failed:\n%s\non input:\n%s", stderr, b.Bytes()) | |
| } | |
| // Scan DWARF info for top-level TagVariable entries with AttrName __cgo__i. | |
| types := make([]dwarf.Type, len(names)) | |
| enums := make([]dwarf.Offset, len(names)) | |
| r := d.Reader() | |
| for { | |
| e, err := r.Next() | |
| if err != nil { | |
| fatal("reading DWARF entry: %s", err) | |
| } | |
| if e == nil { | |
| break | |
| } | |
| switch e.Tag { | |
| case dwarf.TagEnumerationType: | |
| offset := e.Offset | |
| for { | |
| e, err := r.Next() | |
| if err != nil { | |
| fatal("reading DWARF entry: %s", err) | |
| } | |
| if e.Tag == 0 { | |
| break | |
| } | |
| if e.Tag == dwarf.TagEnumerator { | |
| entryName := e.Val(dwarf.AttrName).(string) | |
| i, ok := m[entryName] | |
| if ok { | |
| enums[i] = offset | |
| } | |
| } | |
| } | |
| case dwarf.TagVariable: | |
| name, _ := e.Val(dwarf.AttrName).(string) | |
| typOff, _ := e.Val(dwarf.AttrType).(dwarf.Offset) | |
| if name == "" || typOff == 0 { | |
| fatal("malformed DWARF TagVariable entry") | |
| } | |
| if !strings.HasPrefix(name, "__cgo__") { | |
| break | |
| } | |
| typ, err := d.Type(typOff) | |
| if err != nil { | |
| fatal("loading DWARF type: %s", err) | |
| } | |
| t, ok := typ.(*dwarf.PtrType) | |
| if !ok || t == nil { | |
| fatal("internal error: %s has non-pointer type", name) | |
| } | |
| i, err := strconv.Atoi(name[7:]) | |
| if err != nil { | |
| fatal("malformed __cgo__ name: %s", name) | |
| } | |
| if enums[i] != 0 { | |
| t, err := d.Type(enums[i]) | |
| if err != nil { | |
| fatal("loading DWARF type: %s", err) | |
| } | |
| types[i] = t | |
| } else { | |
| types[i] = t.Type | |
| } | |
| } | |
| if e.Tag != dwarf.TagCompileUnit { | |
| r.SkipChildren() | |
| } | |
| } | |
| // Record types and typedef information in Crefs. | |
| var conv typeConv | |
| conv.Init(p.PtrSize) | |
| for _, c := range p.Crefs { | |
| i, ok := m[c.Name] | |
| if !ok { | |
| if _, ok := p.Constdef[c.Name]; !ok { | |
| fatal("Cref %s is no longer around", c.Name) | |
| } | |
| continue | |
| } | |
| c.TypeName = kind[c.Name] == "type" | |
| f, fok := types[i].(*dwarf.FuncType) | |
| if c.Context == "call" && !c.TypeName && fok { | |
| c.FuncType = conv.FuncType(f) | |
| } else { | |
| c.Type = conv.Type(types[i]) | |
| } | |
| } | |
| p.Typedef = conv.typedef | |
| } | |
| func concat(a, b []string) []string { | |
| c := make([]string, len(a)+len(b)) | |
| for i, s := range a { | |
| c[i] = s | |
| } | |
| for i, s := range b { | |
| c[i+len(a)] = s | |
| } | |
| return c | |
| } | |
| // gccDebug runs gcc -gdwarf-2 over the C program stdin and | |
| // returns the corresponding DWARF data and any messages | |
| // printed to standard error. | |
| func (p *Prog) gccDebug(stdin []byte) (*dwarf.Data, string) { | |
| machine := "-m32" | |
| if p.PtrSize == 8 { | |
| machine = "-m64" | |
| } | |
| tmp := "_cgo_.o" | |
| base := []string{ | |
| "gcc", | |
| machine, | |
| "-Wall", // many warnings | |
| "-Werror", // warnings are errors | |
| "-o" + tmp, // write object to tmp | |
| "-gdwarf-2", // generate DWARF v2 debugging symbols | |
| "-fno-eliminate-unused-debug-types", // gets rid of e.g. untyped enum otherwise | |
| "-c", // do not link | |
| "-xc", // input language is C | |
| "-", // read input from standard input | |
| } | |
| _, stderr, ok := run(stdin, concat(base, p.GccOptions)) | |
| if !ok { | |
| return nil, string(stderr) | |
| } | |
| // Try to parse f as ELF and Mach-O and hope one works. | |
| var f interface { | |
| DWARF() (*dwarf.Data, os.Error) | |
| } | |
| var err os.Error | |
| if f, err = elf.Open(tmp); err != nil { | |
| if f, err = macho.Open(tmp); err != nil { | |
| fatal("cannot parse gcc output %s as ELF or Mach-O object", tmp) | |
| } | |
| } | |
| d, err := f.DWARF() | |
| if err != nil { | |
| fatal("cannot load DWARF debug information from %s: %s", tmp, err) | |
| } | |
| return d, "" | |
| } | |
| func (p *Prog) gccPostProc(stdin []byte) string { | |
| machine := "-m32" | |
| if p.PtrSize == 8 { | |
| machine = "-m64" | |
| } | |
| base := []string{"gcc", machine, "-E", "-dM", "-xc", "-"} | |
| stdout, stderr, ok := run(stdin, concat(base, p.GccOptions)) | |
| if !ok { | |
| return string(stderr) | |
| } | |
| return string(stdout) | |
| } | |
| // A typeConv is a translator from dwarf types to Go types | |
| // with equivalent memory layout. | |
| type typeConv struct { | |
| // Cache of already-translated or in-progress types. | |
| m map[dwarf.Type]*Type | |
| typedef map[string]ast.Expr | |
| // Predeclared types. | |
| bool ast.Expr | |
| byte ast.Expr // denotes padding | |
| int8, int16, int32, int64 ast.Expr | |
| uint8, uint16, uint32, uint64, uintptr ast.Expr | |
| float32, float64 ast.Expr | |
| void ast.Expr | |
| unsafePointer ast.Expr | |
| string ast.Expr | |
| ptrSize int64 | |
| tagGen int | |
| } | |
| func (c *typeConv) Init(ptrSize int64) { | |
| c.ptrSize = ptrSize | |
| c.m = make(map[dwarf.Type]*Type) | |
| c.typedef = make(map[string]ast.Expr) | |
| c.bool = c.Ident("bool") | |
| c.byte = c.Ident("byte") | |
| c.int8 = c.Ident("int8") | |
| c.int16 = c.Ident("int16") | |
| c.int32 = c.Ident("int32") | |
| c.int64 = c.Ident("int64") | |
| c.uint8 = c.Ident("uint8") | |
| c.uint16 = c.Ident("uint16") | |
| c.uint32 = c.Ident("uint32") | |
| c.uint64 = c.Ident("uint64") | |
| c.uintptr = c.Ident("uintptr") | |
| c.float32 = c.Ident("float32") | |
| c.float64 = c.Ident("float64") | |
| c.unsafePointer = c.Ident("unsafe.Pointer") | |
| c.void = c.Ident("void") | |
| c.string = c.Ident("string") | |
| } | |
| // base strips away qualifiers and typedefs to get the underlying type | |
| func base(dt dwarf.Type) dwarf.Type { | |
| for { | |
| if d, ok := dt.(*dwarf.QualType); ok { | |
| dt = d.Type | |
| continue | |
| } | |
| if d, ok := dt.(*dwarf.TypedefType); ok { | |
| dt = d.Type | |
| continue | |
| } | |
| break | |
| } | |
| return dt | |
| } | |
| // Map from dwarf text names to aliases we use in package "C". | |
| var cnameMap = map[string]string{ | |
| "long int": "long", | |
| "long unsigned int": "ulong", | |
| "unsigned int": "uint", | |
| "short unsigned int": "ushort", | |
| "short int": "short", | |
| "long long int": "longlong", | |
| "long long unsigned int": "ulonglong", | |
| "signed char": "schar", | |
| } | |
| // Type returns a *Type with the same memory layout as | |
| // dtype when used as the type of a variable or a struct field. | |
| func (c *typeConv) Type(dtype dwarf.Type) *Type { | |
| if t, ok := c.m[dtype]; ok { | |
| if t.Go == nil { | |
| fatal("type conversion loop at %s", dtype) | |
| } | |
| return t | |
| } | |
| t := new(Type) | |
| t.Size = dtype.Size() | |
| t.Align = -1 | |
| t.C = dtype.Common().Name | |
| t.EnumValues = nil | |
| c.m[dtype] = t | |
| if t.Size < 0 { | |
| // Unsized types are [0]byte | |
| t.Size = 0 | |
| t.Go = c.Opaque(0) | |
| if t.C == "" { | |
| t.C = "void" | |
| } | |
| return t | |
| } | |
| switch dt := dtype.(type) { | |
| default: | |
| fatal("unexpected type: %s", dtype) | |
| case *dwarf.AddrType: | |
| if t.Size != c.ptrSize { | |
| fatal("unexpected: %d-byte address type - %s", t.Size, dtype) | |
| } | |
| t.Go = c.uintptr | |
| t.Align = t.Size | |
| case *dwarf.ArrayType: | |
| if dt.StrideBitSize > 0 { | |
| // Cannot represent bit-sized elements in Go. | |
| t.Go = c.Opaque(t.Size) | |
| break | |
| } | |
| gt := &ast.ArrayType{ | |
| Len: c.intExpr(dt.Count), | |
| } | |
| t.Go = gt // publish before recursive call | |
| sub := c.Type(dt.Type) | |
| t.Align = sub.Align | |
| gt.Elt = sub.Go | |
| t.C = fmt.Sprintf("typeof(%s[%d])", sub.C, dt.Count) | |
| case *dwarf.BoolType: | |
| t.Go = c.bool | |
| t.Align = c.ptrSize | |
| case *dwarf.CharType: | |
| if t.Size != 1 { | |
| fatal("unexpected: %d-byte char type - %s", t.Size, dtype) | |
| } | |
| t.Go = c.int8 | |
| t.Align = 1 | |
| case *dwarf.EnumType: | |
| switch t.Size { | |
| default: | |
| fatal("unexpected: %d-byte enum type - %s", t.Size, dtype) | |
| case 1: | |
| t.Go = c.uint8 | |
| case 2: | |
| t.Go = c.uint16 | |
| case 4: | |
| t.Go = c.uint32 | |
| case 8: | |
| t.Go = c.uint64 | |
| } | |
| if t.Align = t.Size; t.Align >= c.ptrSize { | |
| t.Align = c.ptrSize | |
| } | |
| t.C = "enum " + dt.EnumName | |
| t.EnumValues = make(map[string]int64) | |
| for _, ev := range dt.Val { | |
| t.EnumValues[ev.Name] = ev.Val | |
| } | |
| case *dwarf.FloatType: | |
| switch t.Size { | |
| default: | |
| fatal("unexpected: %d-byte float type - %s", t.Size, dtype) | |
| case 4: | |
| t.Go = c.float32 | |
| case 8: | |
| t.Go = c.float64 | |
| } | |
| if t.Align = t.Size; t.Align >= c.ptrSize { | |
| t.Align = c.ptrSize | |
| } | |
| case *dwarf.FuncType: | |
| // No attempt at translation: would enable calls | |
| // directly between worlds, but we need to moderate those. | |
| t.Go = c.uintptr | |
| t.Align = c.ptrSize | |
| case *dwarf.IntType: | |
| if dt.BitSize > 0 { | |
| fatal("unexpected: %d-bit int type - %s", dt.BitSize, dtype) | |
| } | |
| switch t.Size { | |
| default: | |
| fatal("unexpected: %d-byte int type - %s", t.Size, dtype) | |
| case 1: | |
| t.Go = c.int8 | |
| case 2: | |
| t.Go = c.int16 | |
| case 4: | |
| t.Go = c.int32 | |
| case 8: | |
| t.Go = c.int64 | |
| } | |
| if t.Align = t.Size; t.Align >= c.ptrSize { | |
| t.Align = c.ptrSize | |
| } | |
| case *dwarf.PtrType: | |
| t.Align = c.ptrSize | |
| // Translate void* as unsafe.Pointer | |
| if _, ok := base(dt.Type).(*dwarf.VoidType); ok { | |
| t.Go = c.unsafePointer | |
| t.C = "void*" | |
| break | |
| } | |
| gt := &ast.StarExpr{} | |
| t.Go = gt // publish before recursive call | |
| sub := c.Type(dt.Type) | |
| gt.X = sub.Go | |
| t.C = sub.C + "*" | |
| case *dwarf.QualType: | |
| // Ignore qualifier. | |
| t = c.Type(dt.Type) | |
| c.m[dtype] = t | |
| return t | |
| case *dwarf.StructType: | |
| // Convert to Go struct, being careful about alignment. | |
| // Have to give it a name to simulate C "struct foo" references. | |
| tag := dt.StructName | |
| if tag == "" { | |
| tag = "__" + strconv.Itoa(c.tagGen) | |
| c.tagGen++ | |
| } else if t.C == "" { | |
| t.C = dt.Kind + " " + tag | |
| } | |
| name := c.Ident("_C" + dt.Kind + "_" + tag) | |
| t.Go = name // publish before recursive calls | |
| switch dt.Kind { | |
| case "union", "class": | |
| c.typedef[name.Name()] = c.Opaque(t.Size) | |
| if t.C == "" { | |
| t.C = fmt.Sprintf("typeof(unsigned char[%d])", t.Size) | |
| } | |
| case "struct": | |
| g, csyntax, align := c.Struct(dt) | |
| if t.C == "" { | |
| t.C = csyntax | |
| } | |
| t.Align = align | |
| c.typedef[name.Name()] = g | |
| } | |
| case *dwarf.TypedefType: | |
| // Record typedef for printing. | |
| if dt.Name == "_GoString_" { | |
| // Special C name for Go string type. | |
| // Knows string layout used by compilers: pointer plus length, | |
| // which rounds up to 2 pointers after alignment. | |
| t.Go = c.string | |
| t.Size = c.ptrSize * 2 | |
| t.Align = c.ptrSize | |
| break | |
| } | |
| name := c.Ident("_C_" + dt.Name) | |
| t.Go = name // publish before recursive call | |
| sub := c.Type(dt.Type) | |
| t.Size = sub.Size | |
| t.Align = sub.Align | |
| if _, ok := c.typedef[name.Name()]; !ok { | |
| c.typedef[name.Name()] = sub.Go | |
| } | |
| case *dwarf.UcharType: | |
| if t.Size != 1 { | |
| fatal("unexpected: %d-byte uchar type - %s", t.Size, dtype) | |
| } | |
| t.Go = c.uint8 | |
| t.Align = 1 | |
| case *dwarf.UintType: | |
| if dt.BitSize > 0 { | |
| fatal("unexpected: %d-bit uint type - %s", dt.BitSize, dtype) | |
| } | |
| switch t.Size { | |
| default: | |
| fatal("unexpected: %d-byte uint type - %s", t.Size, dtype) | |
| case 1: | |
| t.Go = c.uint8 | |
| case 2: | |
| t.Go = c.uint16 | |
| case 4: | |
| t.Go = c.uint32 | |
| case 8: | |
| t.Go = c.uint64 | |
| } | |
| if t.Align = t.Size; t.Align >= c.ptrSize { | |
| t.Align = c.ptrSize | |
| } | |
| case *dwarf.VoidType: | |
| t.Go = c.void | |
| t.C = "void" | |
| } | |
| switch dtype.(type) { | |
| case *dwarf.AddrType, *dwarf.BoolType, *dwarf.CharType, *dwarf.IntType, *dwarf.FloatType, *dwarf.UcharType, *dwarf.UintType: | |
| s := dtype.Common().Name | |
| if s != "" { | |
| if ss, ok := cnameMap[s]; ok { | |
| s = ss | |
| } | |
| s = strings.Join(strings.Split(s, " ", 0), "") // strip spaces | |
| name := c.Ident("_C_" + s) | |
| c.typedef[name.Name()] = t.Go | |
| t.Go = name | |
| } | |
| } | |
| if t.C == "" { | |
| fatal("internal error: did not create C name for %s", dtype) | |
| } | |
| return t | |
| } | |
| // FuncArg returns a Go type with the same memory layout as | |
| // dtype when used as the type of a C function argument. | |
| func (c *typeConv) FuncArg(dtype dwarf.Type) *Type { | |
| t := c.Type(dtype) | |
| switch dt := dtype.(type) { | |
| case *dwarf.ArrayType: | |
| // Arrays are passed implicitly as pointers in C. | |
| // In Go, we must be explicit. | |
| return &Type{ | |
| Size: c.ptrSize, | |
| Align: c.ptrSize, | |
| Go: &ast.StarExpr{X: t.Go}, | |
| C: t.C + "*", | |
| } | |
| case *dwarf.TypedefType: | |
| // C has much more relaxed rules than Go for | |
| // implicit type conversions. When the parameter | |
| // is type T defined as *X, simulate a little of the | |
| // laxness of C by making the argument *X instead of T. | |
| if ptr, ok := base(dt.Type).(*dwarf.PtrType); ok { | |
| // Unless the typedef happens to point to void* since | |
| // Go has special rules around using unsafe.Pointer. | |
| if _, void := base(ptr.Type).(*dwarf.VoidType); !void { | |
| return c.Type(ptr) | |
| } | |
| } | |
| } | |
| return t | |
| } | |
| // FuncType returns the Go type analogous to dtype. | |
| // There is no guarantee about matching memory layout. | |
| func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType { | |
| p := make([]*Type, len(dtype.ParamType)) | |
| gp := make([]*ast.Field, len(dtype.ParamType)) | |
| for i, f := range dtype.ParamType { | |
| // gcc's DWARF generator outputs a single DotDotDotType parameter for | |
| // function pointers that specify no parameters (e.g. void | |
| // (*__cgo_0)()). Treat this special case as void. This case is | |
| // invalid according to ISO C anyway (i.e. void (*__cgo_1)(...) is not | |
| // legal). | |
| if _, ok := f.(*dwarf.DotDotDotType); ok && i == 0 { | |
| p, gp = nil, nil | |
| break | |
| } | |
| p[i] = c.FuncArg(f) | |
| gp[i] = &ast.Field{Type: p[i].Go} | |
| } | |
| var r *Type | |
| var gr []*ast.Field | |
| if _, ok := dtype.ReturnType.(*dwarf.VoidType); !ok && dtype.ReturnType != nil { | |
| r = c.Type(dtype.ReturnType) | |
| gr = []*ast.Field{&ast.Field{Type: r.Go}} | |
| } | |
| return &FuncType{ | |
| Params: p, | |
| Result: r, | |
| Go: &ast.FuncType{ | |
| Params: &ast.FieldList{List: gp}, | |
| Results: &ast.FieldList{List: gr}, | |
| }, | |
| } | |
| } | |
| // Identifier | |
| func (c *typeConv) Ident(s string) *ast.Ident { return ast.NewIdent(s) } | |
| // Opaque type of n bytes. | |
| func (c *typeConv) Opaque(n int64) ast.Expr { | |
| return &ast.ArrayType{ | |
| Len: c.intExpr(n), | |
| Elt: c.byte, | |
| } | |
| } | |
| // Expr for integer n. | |
| func (c *typeConv) intExpr(n int64) ast.Expr { | |
| return &ast.BasicLit{ | |
| Kind: token.INT, | |
| Value: []byte(strconv.Itoa64(n)), | |
| } | |
| } | |
| // Add padding of given size to fld. | |
| func (c *typeConv) pad(fld []*ast.Field, size int64) []*ast.Field { | |
| n := len(fld) | |
| fld = fld[0 : n+1] | |
| fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident("_")}, Type: c.Opaque(size)} | |
| return fld | |
| } | |
| // Struct conversion | |
| func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax string, align int64) { | |
| csyntax = "struct { " | |
| fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field | |
| off := int64(0) | |
| // Mangle struct fields that happen to be named Go keywords into | |
| // _{keyword}. Create a map from C ident -> Go ident. The Go ident will | |
| // be mangled. Any existing identifier that already has the same name on | |
| // the C-side will cause the Go-mangled version to be prefixed with _. | |
| // (e.g. in a struct with fields '_type' and 'type', the latter would be | |
| // rendered as '__type' in Go). | |
| ident := make(map[string]string) | |
| used := make(map[string]bool) | |
| for _, f := range dt.Field { | |
| ident[f.Name] = f.Name | |
| used[f.Name] = true | |
| } | |
| for cid, goid := range ident { | |
| if token.Lookup([]byte(goid)).IsKeyword() { | |
| // Avoid keyword | |
| goid = "_" + goid | |
| // Also avoid existing fields | |
| for _, exist := used[goid]; exist; _, exist = used[goid] { | |
| goid = "_" + goid | |
| } | |
| used[goid] = true | |
| ident[cid] = goid | |
| } | |
| } | |
| for _, f := range dt.Field { | |
| if f.BitSize > 0 && f.BitSize != f.ByteSize*8 { | |
| continue | |
| } | |
| if f.ByteOffset > off { | |
| fld = c.pad(fld, f.ByteOffset-off) | |
| off = f.ByteOffset | |
| } | |
| t := c.Type(f.Type) | |
| n := len(fld) | |
| fld = fld[0 : n+1] | |
| fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go} | |
| off += t.Size | |
| csyntax += t.C + " " + f.Name + "; " | |
| if t.Align > align { | |
| align = t.Align | |
| } | |
| } | |
| if off < dt.ByteSize { | |
| fld = c.pad(fld, dt.ByteSize-off) | |
| off = dt.ByteSize | |
| } | |
| if off != dt.ByteSize { | |
| fatal("struct size calculation error") | |
| } | |
| csyntax += "}" | |
| expr = &ast.StructType{Fields: &ast.FieldList{List: fld}} | |
| return | |
| } |