...
Run Format

Source file src/debug/pe/file_test.go

Documentation: debug/pe

     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 pe
     6  
     7  import (
     8  	"debug/dwarf"
     9  	"internal/testenv"
    10  	"io/ioutil"
    11  	"os"
    12  	"os/exec"
    13  	"path/filepath"
    14  	"reflect"
    15  	"regexp"
    16  	"runtime"
    17  	"strconv"
    18  	"testing"
    19  	"text/template"
    20  )
    21  
    22  type fileTest struct {
    23  	file           string
    24  	hdr            FileHeader
    25  	opthdr         interface{}
    26  	sections       []*SectionHeader
    27  	symbols        []*Symbol
    28  	hasNoDwarfInfo bool
    29  }
    30  
    31  var fileTests = []fileTest{
    32  	{
    33  		file: "testdata/gcc-386-mingw-obj",
    34  		hdr:  FileHeader{0x014c, 0x000c, 0x0, 0x64a, 0x1e, 0x0, 0x104},
    35  		sections: []*SectionHeader{
    36  			{".text", 0, 0, 36, 500, 1440, 0, 3, 0, 0x60300020},
    37  			{".data", 0, 0, 0, 0, 0, 0, 0, 0, 3224371264},
    38  			{".bss", 0, 0, 0, 0, 0, 0, 0, 0, 3224371328},
    39  			{".debug_abbrev", 0, 0, 137, 536, 0, 0, 0, 0, 0x42100000},
    40  			{".debug_info", 0, 0, 418, 673, 1470, 0, 7, 0, 1108344832},
    41  			{".debug_line", 0, 0, 128, 1091, 1540, 0, 1, 0, 1108344832},
    42  			{".rdata", 0, 0, 16, 1219, 0, 0, 0, 0, 1076887616},
    43  			{".debug_frame", 0, 0, 52, 1235, 1550, 0, 2, 0, 1110441984},
    44  			{".debug_loc", 0, 0, 56, 1287, 0, 0, 0, 0, 1108344832},
    45  			{".debug_pubnames", 0, 0, 27, 1343, 1570, 0, 1, 0, 1108344832},
    46  			{".debug_pubtypes", 0, 0, 38, 1370, 1580, 0, 1, 0, 1108344832},
    47  			{".debug_aranges", 0, 0, 32, 1408, 1590, 0, 2, 0, 1108344832},
    48  		},
    49  		symbols: []*Symbol{
    50  			{".file", 0x0, -2, 0x0, 0x67},
    51  			{"_main", 0x0, 1, 0x20, 0x2},
    52  			{".text", 0x0, 1, 0x0, 0x3},
    53  			{".data", 0x0, 2, 0x0, 0x3},
    54  			{".bss", 0x0, 3, 0x0, 0x3},
    55  			{".debug_abbrev", 0x0, 4, 0x0, 0x3},
    56  			{".debug_info", 0x0, 5, 0x0, 0x3},
    57  			{".debug_line", 0x0, 6, 0x0, 0x3},
    58  			{".rdata", 0x0, 7, 0x0, 0x3},
    59  			{".debug_frame", 0x0, 8, 0x0, 0x3},
    60  			{".debug_loc", 0x0, 9, 0x0, 0x3},
    61  			{".debug_pubnames", 0x0, 10, 0x0, 0x3},
    62  			{".debug_pubtypes", 0x0, 11, 0x0, 0x3},
    63  			{".debug_aranges", 0x0, 12, 0x0, 0x3},
    64  			{"___main", 0x0, 0, 0x20, 0x2},
    65  			{"_puts", 0x0, 0, 0x20, 0x2},
    66  		},
    67  	},
    68  	{
    69  		file: "testdata/gcc-386-mingw-exec",
    70  		hdr:  FileHeader{0x014c, 0x000f, 0x4c6a1b60, 0x3c00, 0x282, 0xe0, 0x107},
    71  		opthdr: &OptionalHeader32{
    72  			0x10b, 0x2, 0x38, 0xe00, 0x1a00, 0x200, 0x1160, 0x1000, 0x2000, 0x400000, 0x1000, 0x200, 0x4, 0x0, 0x1, 0x0, 0x4, 0x0, 0x0, 0x10000, 0x400, 0x14abb, 0x3, 0x0, 0x200000, 0x1000, 0x100000, 0x1000, 0x0, 0x10,
    73  			[16]DataDirectory{
    74  				{0x0, 0x0},
    75  				{0x5000, 0x3c8},
    76  				{0x0, 0x0},
    77  				{0x0, 0x0},
    78  				{0x0, 0x0},
    79  				{0x0, 0x0},
    80  				{0x0, 0x0},
    81  				{0x0, 0x0},
    82  				{0x0, 0x0},
    83  				{0x7000, 0x18},
    84  				{0x0, 0x0},
    85  				{0x0, 0x0},
    86  				{0x0, 0x0},
    87  				{0x0, 0x0},
    88  				{0x0, 0x0},
    89  				{0x0, 0x0},
    90  			},
    91  		},
    92  		sections: []*SectionHeader{
    93  			{".text", 0xcd8, 0x1000, 0xe00, 0x400, 0x0, 0x0, 0x0, 0x0, 0x60500060},
    94  			{".data", 0x10, 0x2000, 0x200, 0x1200, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
    95  			{".rdata", 0x120, 0x3000, 0x200, 0x1400, 0x0, 0x0, 0x0, 0x0, 0x40300040},
    96  			{".bss", 0xdc, 0x4000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0400080},
    97  			{".idata", 0x3c8, 0x5000, 0x400, 0x1600, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
    98  			{".CRT", 0x18, 0x6000, 0x200, 0x1a00, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
    99  			{".tls", 0x20, 0x7000, 0x200, 0x1c00, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   100  			{".debug_aranges", 0x20, 0x8000, 0x200, 0x1e00, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   101  			{".debug_pubnames", 0x51, 0x9000, 0x200, 0x2000, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   102  			{".debug_pubtypes", 0x91, 0xa000, 0x200, 0x2200, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   103  			{".debug_info", 0xe22, 0xb000, 0x1000, 0x2400, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   104  			{".debug_abbrev", 0x157, 0xc000, 0x200, 0x3400, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   105  			{".debug_line", 0x144, 0xd000, 0x200, 0x3600, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   106  			{".debug_frame", 0x34, 0xe000, 0x200, 0x3800, 0x0, 0x0, 0x0, 0x0, 0x42300000},
   107  			{".debug_loc", 0x38, 0xf000, 0x200, 0x3a00, 0x0, 0x0, 0x0, 0x0, 0x42100000},
   108  		},
   109  	},
   110  	{
   111  		file: "testdata/gcc-386-mingw-no-symbols-exec",
   112  		hdr:  FileHeader{0x14c, 0x8, 0x69676572, 0x0, 0x0, 0xe0, 0x30f},
   113  		opthdr: &OptionalHeader32{0x10b, 0x2, 0x18, 0xe00, 0x1e00, 0x200, 0x1280, 0x1000, 0x2000, 0x400000, 0x1000, 0x200, 0x4, 0x0, 0x1, 0x0, 0x4, 0x0, 0x0, 0x9000, 0x400, 0x5306, 0x3, 0x0, 0x200000, 0x1000, 0x100000, 0x1000, 0x0, 0x10,
   114  			[16]DataDirectory{
   115  				{0x0, 0x0},
   116  				{0x6000, 0x378},
   117  				{0x0, 0x0},
   118  				{0x0, 0x0},
   119  				{0x0, 0x0},
   120  				{0x0, 0x0},
   121  				{0x0, 0x0},
   122  				{0x0, 0x0},
   123  				{0x0, 0x0},
   124  				{0x8004, 0x18},
   125  				{0x0, 0x0},
   126  				{0x0, 0x0},
   127  				{0x60b8, 0x7c},
   128  				{0x0, 0x0},
   129  				{0x0, 0x0},
   130  				{0x0, 0x0},
   131  			},
   132  		},
   133  		sections: []*SectionHeader{
   134  			{".text", 0xc64, 0x1000, 0xe00, 0x400, 0x0, 0x0, 0x0, 0x0, 0x60500060},
   135  			{".data", 0x10, 0x2000, 0x200, 0x1200, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   136  			{".rdata", 0x134, 0x3000, 0x200, 0x1400, 0x0, 0x0, 0x0, 0x0, 0x40300040},
   137  			{".eh_fram", 0x3a0, 0x4000, 0x400, 0x1600, 0x0, 0x0, 0x0, 0x0, 0x40300040},
   138  			{".bss", 0x60, 0x5000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0300080},
   139  			{".idata", 0x378, 0x6000, 0x400, 0x1a00, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   140  			{".CRT", 0x18, 0x7000, 0x200, 0x1e00, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   141  			{".tls", 0x20, 0x8000, 0x200, 0x2000, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   142  		},
   143  		hasNoDwarfInfo: true,
   144  	},
   145  	{
   146  		file: "testdata/gcc-amd64-mingw-obj",
   147  		hdr:  FileHeader{0x8664, 0x6, 0x0, 0x198, 0x12, 0x0, 0x4},
   148  		sections: []*SectionHeader{
   149  			{".text", 0x0, 0x0, 0x30, 0x104, 0x15c, 0x0, 0x3, 0x0, 0x60500020},
   150  			{".data", 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0500040},
   151  			{".bss", 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0500080},
   152  			{".rdata", 0x0, 0x0, 0x10, 0x134, 0x0, 0x0, 0x0, 0x0, 0x40500040},
   153  			{".xdata", 0x0, 0x0, 0xc, 0x144, 0x0, 0x0, 0x0, 0x0, 0x40300040},
   154  			{".pdata", 0x0, 0x0, 0xc, 0x150, 0x17a, 0x0, 0x3, 0x0, 0x40300040},
   155  		},
   156  		symbols: []*Symbol{
   157  			{".file", 0x0, -2, 0x0, 0x67},
   158  			{"main", 0x0, 1, 0x20, 0x2},
   159  			{".text", 0x0, 1, 0x0, 0x3},
   160  			{".data", 0x0, 2, 0x0, 0x3},
   161  			{".bss", 0x0, 3, 0x0, 0x3},
   162  			{".rdata", 0x0, 4, 0x0, 0x3},
   163  			{".xdata", 0x0, 5, 0x0, 0x3},
   164  			{".pdata", 0x0, 6, 0x0, 0x3},
   165  			{"__main", 0x0, 0, 0x20, 0x2},
   166  			{"puts", 0x0, 0, 0x20, 0x2},
   167  		},
   168  		hasNoDwarfInfo: true,
   169  	},
   170  	{
   171  		file: "testdata/gcc-amd64-mingw-exec",
   172  		hdr:  FileHeader{0x8664, 0x11, 0x53e4364f, 0x39600, 0x6fc, 0xf0, 0x27},
   173  		opthdr: &OptionalHeader64{
   174  			0x20b, 0x2, 0x16, 0x6a00, 0x2400, 0x1600, 0x14e0, 0x1000, 0x400000, 0x1000, 0x200, 0x4, 0x0, 0x0, 0x0, 0x5, 0x2, 0x0, 0x45000, 0x600, 0x46f19, 0x3, 0x0, 0x200000, 0x1000, 0x100000, 0x1000, 0x0, 0x10,
   175  			[16]DataDirectory{
   176  				{0x0, 0x0},
   177  				{0xe000, 0x990},
   178  				{0x0, 0x0},
   179  				{0xa000, 0x498},
   180  				{0x0, 0x0},
   181  				{0x0, 0x0},
   182  				{0x0, 0x0},
   183  				{0x0, 0x0},
   184  				{0x0, 0x0},
   185  				{0x10000, 0x28},
   186  				{0x0, 0x0},
   187  				{0x0, 0x0},
   188  				{0xe254, 0x218},
   189  				{0x0, 0x0},
   190  				{0x0, 0x0},
   191  				{0x0, 0x0},
   192  			}},
   193  		sections: []*SectionHeader{
   194  			{".text", 0x6860, 0x1000, 0x6a00, 0x600, 0x0, 0x0, 0x0, 0x0, 0x60500020},
   195  			{".data", 0xe0, 0x8000, 0x200, 0x7000, 0x0, 0x0, 0x0, 0x0, 0xc0500040},
   196  			{".rdata", 0x6b0, 0x9000, 0x800, 0x7200, 0x0, 0x0, 0x0, 0x0, 0x40600040},
   197  			{".pdata", 0x498, 0xa000, 0x600, 0x7a00, 0x0, 0x0, 0x0, 0x0, 0x40300040},
   198  			{".xdata", 0x488, 0xb000, 0x600, 0x8000, 0x0, 0x0, 0x0, 0x0, 0x40300040},
   199  			{".bss", 0x1410, 0xc000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0600080},
   200  			{".idata", 0x990, 0xe000, 0xa00, 0x8600, 0x0, 0x0, 0x0, 0x0, 0xc0300040},
   201  			{".CRT", 0x68, 0xf000, 0x200, 0x9000, 0x0, 0x0, 0x0, 0x0, 0xc0400040},
   202  			{".tls", 0x48, 0x10000, 0x200, 0x9200, 0x0, 0x0, 0x0, 0x0, 0xc0600040},
   203  			{".debug_aranges", 0x600, 0x11000, 0x600, 0x9400, 0x0, 0x0, 0x0, 0x0, 0x42500040},
   204  			{".debug_info", 0x1316e, 0x12000, 0x13200, 0x9a00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   205  			{".debug_abbrev", 0x2ccb, 0x26000, 0x2e00, 0x1cc00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   206  			{".debug_line", 0x3c4d, 0x29000, 0x3e00, 0x1fa00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   207  			{".debug_frame", 0x18b8, 0x2d000, 0x1a00, 0x23800, 0x0, 0x0, 0x0, 0x0, 0x42400040},
   208  			{".debug_str", 0x396, 0x2f000, 0x400, 0x25200, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   209  			{".debug_loc", 0x13240, 0x30000, 0x13400, 0x25600, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   210  			{".debug_ranges", 0xa70, 0x44000, 0xc00, 0x38a00, 0x0, 0x0, 0x0, 0x0, 0x42100040},
   211  		},
   212  	},
   213  }
   214  
   215  func isOptHdrEq(a, b interface{}) bool {
   216  	switch va := a.(type) {
   217  	case *OptionalHeader32:
   218  		vb, ok := b.(*OptionalHeader32)
   219  		if !ok {
   220  			return false
   221  		}
   222  		return *vb == *va
   223  	case *OptionalHeader64:
   224  		vb, ok := b.(*OptionalHeader64)
   225  		if !ok {
   226  			return false
   227  		}
   228  		return *vb == *va
   229  	case nil:
   230  		return b == nil
   231  	}
   232  	return false
   233  }
   234  
   235  func TestOpen(t *testing.T) {
   236  	for i := range fileTests {
   237  		tt := &fileTests[i]
   238  
   239  		f, err := Open(tt.file)
   240  		if err != nil {
   241  			t.Error(err)
   242  			continue
   243  		}
   244  		if !reflect.DeepEqual(f.FileHeader, tt.hdr) {
   245  			t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.FileHeader, tt.hdr)
   246  			continue
   247  		}
   248  		if !isOptHdrEq(tt.opthdr, f.OptionalHeader) {
   249  			t.Errorf("open %s:\n\thave %#v\n\twant %#v\n", tt.file, f.OptionalHeader, tt.opthdr)
   250  			continue
   251  		}
   252  
   253  		for i, sh := range f.Sections {
   254  			if i >= len(tt.sections) {
   255  				break
   256  			}
   257  			have := &sh.SectionHeader
   258  			want := tt.sections[i]
   259  			if !reflect.DeepEqual(have, want) {
   260  				t.Errorf("open %s, section %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want)
   261  			}
   262  		}
   263  		tn := len(tt.sections)
   264  		fn := len(f.Sections)
   265  		if tn != fn {
   266  			t.Errorf("open %s: len(Sections) = %d, want %d", tt.file, fn, tn)
   267  		}
   268  		for i, have := range f.Symbols {
   269  			if i >= len(tt.symbols) {
   270  				break
   271  			}
   272  			want := tt.symbols[i]
   273  			if !reflect.DeepEqual(have, want) {
   274  				t.Errorf("open %s, symbol %d:\n\thave %#v\n\twant %#v\n", tt.file, i, have, want)
   275  			}
   276  		}
   277  		if !tt.hasNoDwarfInfo {
   278  			_, err = f.DWARF()
   279  			if err != nil {
   280  				t.Errorf("fetching %s dwarf details failed: %v", tt.file, err)
   281  			}
   282  		}
   283  	}
   284  }
   285  
   286  func TestOpenFailure(t *testing.T) {
   287  	filename := "file.go"    // not a PE file
   288  	_, err := Open(filename) // don't crash
   289  	if err == nil {
   290  		t.Errorf("open %s: succeeded unexpectedly", filename)
   291  	}
   292  }
   293  
   294  const (
   295  	linkNoCgo = iota
   296  	linkCgoDefault
   297  	linkCgoInternal
   298  	linkCgoExternal
   299  )
   300  
   301  func testDWARF(t *testing.T, linktype int) {
   302  	if runtime.GOOS != "windows" {
   303  		t.Skip("skipping windows only test")
   304  	}
   305  	testenv.MustHaveGoRun(t)
   306  
   307  	tmpdir, err := ioutil.TempDir("", "TestDWARF")
   308  	if err != nil {
   309  		t.Fatal(err)
   310  	}
   311  	defer os.RemoveAll(tmpdir)
   312  
   313  	src := filepath.Join(tmpdir, "a.go")
   314  	file, err := os.Create(src)
   315  	if err != nil {
   316  		t.Fatal(err)
   317  	}
   318  	err = template.Must(template.New("main").Parse(testprog)).Execute(file, linktype != linkNoCgo)
   319  	if err != nil {
   320  		if err := file.Close(); err != nil {
   321  			t.Error(err)
   322  		}
   323  		t.Fatal(err)
   324  	}
   325  	if err := file.Close(); err != nil {
   326  		t.Fatal(err)
   327  	}
   328  
   329  	exe := filepath.Join(tmpdir, "a.exe")
   330  	args := []string{"build", "-o", exe}
   331  	switch linktype {
   332  	case linkNoCgo:
   333  	case linkCgoDefault:
   334  	case linkCgoInternal:
   335  		args = append(args, "-ldflags", "-linkmode=internal")
   336  	case linkCgoExternal:
   337  		args = append(args, "-ldflags", "-linkmode=external")
   338  	default:
   339  		t.Fatalf("invalid linktype parameter of %v", linktype)
   340  	}
   341  	args = append(args, src)
   342  	out, err := exec.Command(testenv.GoToolPath(t), args...).CombinedOutput()
   343  	if err != nil {
   344  		t.Fatalf("building test executable for linktype %d failed: %s %s", linktype, err, out)
   345  	}
   346  	out, err = exec.Command(exe).CombinedOutput()
   347  	if err != nil {
   348  		t.Fatalf("running test executable failed: %s %s", err, out)
   349  	}
   350  
   351  	matches := regexp.MustCompile("main=(.*)\n").FindStringSubmatch(string(out))
   352  	if len(matches) < 2 {
   353  		t.Fatalf("unexpected program output: %s", out)
   354  	}
   355  	wantaddr, err := strconv.ParseUint(matches[1], 0, 64)
   356  	if err != nil {
   357  		t.Fatalf("unexpected main address %q: %s", matches[1], err)
   358  	}
   359  
   360  	f, err := Open(exe)
   361  	if err != nil {
   362  		t.Fatal(err)
   363  	}
   364  	defer f.Close()
   365  
   366  	var foundDebugGDBScriptsSection bool
   367  	for _, sect := range f.Sections {
   368  		if sect.Name == ".debug_gdb_scripts" {
   369  			foundDebugGDBScriptsSection = true
   370  		}
   371  	}
   372  	if !foundDebugGDBScriptsSection {
   373  		t.Error(".debug_gdb_scripts section is not found")
   374  	}
   375  
   376  	d, err := f.DWARF()
   377  	if err != nil {
   378  		t.Fatal(err)
   379  	}
   380  
   381  	// look for main.main
   382  	r := d.Reader()
   383  	for {
   384  		e, err := r.Next()
   385  		if err != nil {
   386  			t.Fatal("r.Next:", err)
   387  		}
   388  		if e == nil {
   389  			break
   390  		}
   391  		if e.Tag == dwarf.TagSubprogram {
   392  			if name, ok := e.Val(dwarf.AttrName).(string); ok && name == "main.main" {
   393  				if addr, ok := e.Val(dwarf.AttrLowpc).(uint64); ok && addr == wantaddr {
   394  					return
   395  				}
   396  			}
   397  		}
   398  	}
   399  	t.Fatal("main.main not found")
   400  }
   401  
   402  func TestBSSHasZeros(t *testing.T) {
   403  	testenv.MustHaveExec(t)
   404  
   405  	if runtime.GOOS != "windows" {
   406  		t.Skip("skipping windows only test")
   407  	}
   408  	gccpath, err := exec.LookPath("gcc")
   409  	if err != nil {
   410  		t.Skip("skipping test: gcc is missing")
   411  	}
   412  
   413  	tmpdir, err := ioutil.TempDir("", "TestBSSHasZeros")
   414  	if err != nil {
   415  		t.Fatal(err)
   416  	}
   417  	defer os.RemoveAll(tmpdir)
   418  
   419  	srcpath := filepath.Join(tmpdir, "a.c")
   420  	src := `
   421  #include <stdio.h>
   422  
   423  int zero = 0;
   424  
   425  int
   426  main(void)
   427  {
   428  	printf("%d\n", zero);
   429  	return 0;
   430  }
   431  `
   432  	err = ioutil.WriteFile(srcpath, []byte(src), 0644)
   433  	if err != nil {
   434  		t.Fatal(err)
   435  	}
   436  
   437  	objpath := filepath.Join(tmpdir, "a.obj")
   438  	cmd := exec.Command(gccpath, "-c", srcpath, "-o", objpath)
   439  	out, err := cmd.CombinedOutput()
   440  	if err != nil {
   441  		t.Fatalf("failed to build object file: %v - %v", err, string(out))
   442  	}
   443  
   444  	f, err := Open(objpath)
   445  	if err != nil {
   446  		t.Fatal(err)
   447  	}
   448  	defer f.Close()
   449  
   450  	var bss *Section
   451  	for _, sect := range f.Sections {
   452  		if sect.Name == ".bss" {
   453  			bss = sect
   454  			break
   455  		}
   456  	}
   457  	if bss == nil {
   458  		t.Fatal("could not find .bss section")
   459  	}
   460  	data, err := bss.Data()
   461  	if err != nil {
   462  		t.Fatal(err)
   463  	}
   464  	if len(data) == 0 {
   465  		t.Fatalf("%s file .bss section cannot be empty", objpath)
   466  	}
   467  	for _, b := range data {
   468  		if b != 0 {
   469  			t.Fatalf(".bss section has non zero bytes: %v", data)
   470  		}
   471  	}
   472  }
   473  
   474  func TestDWARF(t *testing.T) {
   475  	testDWARF(t, linkNoCgo)
   476  }
   477  
   478  const testprog = `
   479  package main
   480  
   481  import "fmt"
   482  {{if .}}import "C"
   483  {{end}}
   484  
   485  func main() {
   486  	fmt.Printf("main=%p\n", main)
   487  }
   488  `
   489  
   490  func TestBuildingWindowsGUI(t *testing.T) {
   491  	testenv.MustHaveGoBuild(t)
   492  
   493  	if runtime.GOOS != "windows" {
   494  		t.Skip("skipping windows only test")
   495  	}
   496  	tmpdir, err := ioutil.TempDir("", "TestBuildingWindowsGUI")
   497  	if err != nil {
   498  		t.Fatal(err)
   499  	}
   500  	defer os.RemoveAll(tmpdir)
   501  
   502  	src := filepath.Join(tmpdir, "a.go")
   503  	err = ioutil.WriteFile(src, []byte(`package main; func main() {}`), 0644)
   504  	if err != nil {
   505  		t.Fatal(err)
   506  	}
   507  	exe := filepath.Join(tmpdir, "a.exe")
   508  	cmd := exec.Command(testenv.GoToolPath(t), "build", "-ldflags", "-H=windowsgui", "-o", exe, src)
   509  	out, err := cmd.CombinedOutput()
   510  	if err != nil {
   511  		t.Fatalf("building test executable failed: %s %s", err, out)
   512  	}
   513  
   514  	f, err := Open(exe)
   515  	if err != nil {
   516  		t.Fatal(err)
   517  	}
   518  	defer f.Close()
   519  
   520  	const _IMAGE_SUBSYSTEM_WINDOWS_GUI = 2
   521  
   522  	switch oh := f.OptionalHeader.(type) {
   523  	case *OptionalHeader32:
   524  		if oh.Subsystem != _IMAGE_SUBSYSTEM_WINDOWS_GUI {
   525  			t.Errorf("unexpected Subsystem value: have %d, but want %d", oh.Subsystem, _IMAGE_SUBSYSTEM_WINDOWS_GUI)
   526  		}
   527  	case *OptionalHeader64:
   528  		if oh.Subsystem != _IMAGE_SUBSYSTEM_WINDOWS_GUI {
   529  			t.Errorf("unexpected Subsystem value: have %d, but want %d", oh.Subsystem, _IMAGE_SUBSYSTEM_WINDOWS_GUI)
   530  		}
   531  	default:
   532  		t.Fatalf("unexpected OptionalHeader type: have %T, but want *pe.OptionalHeader32 or *pe.OptionalHeader64", oh)
   533  	}
   534  }
   535  

View as plain text