code review 3906041: allows cgo to handle 'float complex' and 'double comple...

src/cmd/cgo/gcc.go

 // 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 Ref 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"
         "debug/pe"
         "flag"
         "fmt"
         "go/ast"
         "go/parser"
         "go/token"
         "os"
         "strconv"
         "strings"
 )
 
 var debugDefine = flag.Bool("debug-define", false, "print relevant #defines")
 var debugGcc = flag.Bool("debug-gcc", false, "print gcc invocations")
 
 var nameToC = map[string]string{
-        "schar":     "signed char",
-        "uchar":     "unsigned char",
-        "ushort":    "unsigned short",
-        "uint":      "unsigned int",
-        "ulong":     "unsigned long",
-        "longlong":  "long long",
-        "ulonglong": "unsigned long long",
+        "schar":      "signed char",
+        "uchar":      "unsigned char",
+        "ushort":     "unsigned short",
+        "uint":       "unsigned int",
+        "ulong":      "unsigned long",
+        "longlong":   "long long",
+        "ulonglong":  "unsigned long long",
+        "complexfloat":  "float complex",
+        "complexdouble": "double complex",
 }
 
 // cname returns the C name to use for C.s.
 // The expansions are listed in nameToC and also
 // struct_foo becomes "struct foo", and similarly for
 // union and enum.
 func cname(s string) string {
         if t, ok := nameToC[s]; ok {
                 return t
         }
@@ skipping 533 matching lines @@
         // 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
+        complex64, complex128                  ast.Expr
         void                                   ast.Expr
         unsafePointer                          ast.Expr
         string                                 ast.Expr
 
         ptrSize int64
 }
 
 var tagGen int
 var typedef = make(map[string]ast.Expr)
 
 func (c *typeConv) Init(ptrSize int64) {
         c.ptrSize = ptrSize
         c.m = make(map[dwarf.Type]*Type)
         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.complex64 = c.Ident("complex64")
+        c.complex128 = c.Ident("complex128")
         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
@@ skipping 11 matching lines @@
 // Map from dwarf text names to aliases we use in package "C".
 var dwarfToName = 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",
+        "float complex":          "complexfloat",
+        "double complex":         "complexdouble",
 }
 
 // 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
@@ skipping 81 matching lines @@
                         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.ComplexType:
+                switch t.Size {
+                default:
+                        fatal("unexpected: %d-byte complex type - %s", t.Size, dtype)
+                case 8:
+                        t.Go = c.complex64
+                case 16:
+                        t.Go = c.complex128
+                }
+                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)
                 }
@@ skipping 289 matching lines @@
                 off = dt.ByteSize
         }
         if off != dt.ByteSize {
                 fatal("struct size calculation error")
         }
         buf.WriteString("}")
         csyntax = buf.String()
         expr = &ast.StructType{Fields: &ast.FieldList{List: fld}}
         return
 }