libgo/go/debug/dwarf/type_test.go

   1 // Copyright 2009 The Go Authors.  All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package dwarf_test
   6
   7 import (
   8         . "debug/dwarf"
   9         "debug/elf"
  10         "debug/macho"
  11         "testing"
  12 )
  13
  14 var typedefTests = map[string]string{
  15         "t_ptr_volatile_int":                    "*volatile int",
  16         "t_ptr_const_char":                      "*const char",
  17         "t_long":                                "long int",
  18         "t_ushort":                              "short unsigned int",
  19         "t_func_int_of_float_double":            "func(float, double) int",
  20         "t_ptr_func_int_of_float_double":        "*func(float, double) int",
  21         "t_ptr_func_int_of_float_complex":       "*func(complex float) int",
  22         "t_ptr_func_int_of_double_complex":      "*func(complex double) int",
  23         "t_ptr_func_int_of_long_double_complex": "*func(complex long double) int",
  24         "t_func_ptr_int_of_char_schar_uchar":    "func(char, signed char, unsigned char) *int",
  25         "t_func_void_of_char":                   "func(char) void",
  26         "t_func_void_of_void":                   "func() void",
  27         "t_func_void_of_ptr_char_dots":          "func(*char, ...) void",
  28         "t_my_struct":                           "struct my_struct {vi volatile int@0; x char@4 : 1@7; y int@4 : 4@27; z [0]int@8; array [40]long long int@8; zz [0]int@328}",
  29         "t_my_struct1":                          "struct my_struct1 {zz [1]int@0}",
  30         "t_my_union":                            "union my_union {vi volatile int@0; x char@0 : 1@7; y int@0 : 4@28; array [40]long long int@0}",
  31         "t_my_enum":                             "enum my_enum {e1=1; e2=2; e3=-5; e4=1000000000000000}",
  32         "t_my_list":                             "struct list {val short int@0; next *t_my_list@8}",
  33         "t_my_tree":                             "struct tree {left *struct tree@0; right *struct tree@8; val long long unsigned int@16}",
  34 }
  35
  36 // As Apple converts gcc to a clang-based front end
  37 // they keep breaking the DWARF output.  This map lists the
  38 // conversion from real answer to Apple answer.
  39 var machoBug = map[string]string{
  40         "func(*char, ...) void":                                 "func(*char) void",
  41         "enum my_enum {e1=1; e2=2; e3=-5; e4=1000000000000000}": "enum my_enum {e1=1; e2=2; e3=-5; e4=-1530494976}",
  42 }
  43
  44 func elfData(t *testing.T, name string) *Data {
  45         f, err := elf.Open(name)
  46         if err != nil {
  47                 t.Fatal(err)
  48         }
  49
  50         d, err := f.DWARF()
  51         if err != nil {
  52                 t.Fatal(err)
  53         }
  54         return d
  55 }
  56
  57 func machoData(t *testing.T, name string) *Data {
  58         f, err := macho.Open(name)
  59         if err != nil {
  60                 t.Fatal(err)
  61         }
  62
  63         d, err := f.DWARF()
  64         if err != nil {
  65                 t.Fatal(err)
  66         }
  67         return d
  68 }
  69
  70 func TestTypedefsELF(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf"), "elf") }
  71
  72 func TestTypedefsMachO(t *testing.T) {
  73         testTypedefs(t, machoData(t, "testdata/typedef.macho"), "macho")
  74 }
  75
  76 func TestTypedefsELFDwarf4(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf4"), "elf") }
  77
  78 func testTypedefs(t *testing.T, d *Data, kind string) {
  79         r := d.Reader()
  80         seen := make(map[string]bool)
  81         for {
  82                 e, err := r.Next()
  83                 if err != nil {
  84                         t.Fatal("r.Next:", err)
  85                 }
  86                 if e == nil {
  87                         break
  88                 }
  89                 if e.Tag == TagTypedef {
  90                         typ, err := d.Type(e.Offset)
  91                         if err != nil {
  92                                 t.Fatal("d.Type:", err)
  93                         }
  94                         t1 := typ.(*TypedefType)
  95                         var typstr string
  96                         if ts, ok := t1.Type.(*StructType); ok {
  97                                 typstr = ts.Defn()
  98                         } else {
  99                                 typstr = t1.Type.String()
 100                         }
 101
 102                         if want, ok := typedefTests[t1.Name]; ok {
 103                                 if seen[t1.Name] {
 104                                         t.Errorf("multiple definitions for %s", t1.Name)
 105                                 }
 106                                 seen[t1.Name] = true
 107                                 if typstr != want && (kind != "macho" || typstr != machoBug[want]) {
 108                                         t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want)
 109                                 }
 110                         }
 111                 }
 112                 if e.Tag != TagCompileUnit {
 113                         r.SkipChildren()
 114                 }
 115         }
 116
 117         for k := range typedefTests {
 118                 if !seen[k] {
 119                         t.Errorf("missing %s", k)
 120                 }
 121         }
 122 }