From dffc9319f187b8a993968833b3692fc31abbdf1e Mon Sep 17 00:00:00 2001 From: Hiroshi Ioka Date: Thu, 31 Aug 2017 13:49:43 +0900 Subject: [PATCH] [release-branch.go1.9] cmd/cgo: support large unsigned macro again The approach of https://golang.org/cl/43476 turned out incorrect. The problem is that the sniff introduced by the CL only work for simple expression. And when it fails it fallback to uint64, not int64, which breaks backward compatibility. In this CL, we use DWARF for guessing kind instead. That should be more reliable than previous approach. And importanly, it fallbacks to int64 even if it fails to guess kind. Fixes #21708 Change-Id: I39a18cb2efbe4faa9becdcf53d5ac68dba180d47 Reviewed-on: https://go-review.googlesource.com/60510 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Ian Lance Taylor Reviewed-on: https://go-review.googlesource.com/60810 Reviewed-by: Hiroshi Ioka Reviewed-by: Chris Broadfoot Reviewed-on: https://go-review.googlesource.com/70970 Run-TryBot: Russ Cox --- misc/cgo/test/cgo_test.go | 1 + misc/cgo/test/issue21708.go | 16 +++++++++++++++ src/cmd/cgo/gcc.go | 39 ++++++++++--------------------------- src/cmd/cgo/main.go | 4 ++-- 4 files changed, 29 insertions(+), 31 deletions(-) create mode 100644 misc/cgo/test/issue21708.go diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go index f7cf6f613c..9485e25bf4 100644 --- a/misc/cgo/test/cgo_test.go +++ b/misc/cgo/test/cgo_test.go @@ -80,5 +80,6 @@ func Test20369(t *testing.T) { test20369(t) } func Test18720(t *testing.T) { test18720(t) } func Test20266(t *testing.T) { test20266(t) } func Test20129(t *testing.T) { test20129(t) } +func Test21708(t *testing.T) { test21708(t) } func BenchmarkCgoCall(b *testing.B) { benchCgoCall(b) } diff --git a/misc/cgo/test/issue21708.go b/misc/cgo/test/issue21708.go new file mode 100644 index 0000000000..d413e3c57a --- /dev/null +++ b/misc/cgo/test/issue21708.go @@ -0,0 +1,16 @@ +// Copyright 2017 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. + +package cgotest + +// #include +// #define CAST_TO_INT64 (int64_t)(-1) +import "C" +import "testing" + +func test21708(t *testing.T) { + if got, want := C.CAST_TO_INT64, -1; got != want { + t.Errorf("C.CAST_TO_INT64 == %v, expected %v", got, want) + } +} diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go index c47d1fba8d..c104067a93 100644 --- a/src/cmd/cgo/gcc.go +++ b/src/cmd/cgo/gcc.go @@ -305,18 +305,12 @@ func (p *Package) guessKinds(f *File) []*Name { // void __cgo_f_xxx_4(void) { static const double __cgo_undefined__4 = (name); } // #line xxx "not-str-lit" // void __cgo_f_xxx_5(void) { static const char __cgo_undefined__5[] = (name); } - // #line xxx "not-signed-int-const" - // #if 0 < -(name) - // #line xxx "not-signed-int-const" - // #error found unsigned int - // #endif // // If we see an error at not-declared:xxx, the corresponding name is not declared. // If we see an error at not-type:xxx, the corresponding name is a type. // If we see an error at not-int-const:xxx, the corresponding name is not an integer constant. // If we see an error at not-num-const:xxx, the corresponding name is not a number constant. // If we see an error at not-str-lit:xxx, the corresponding name is not a string literal. - // If we see an error at not-signed-int-const:xxx, the corresponding name is not a signed integer literal. // // The specific input forms are chosen so that they are valid C syntax regardless of // whether name denotes a type or an expression. @@ -335,18 +329,12 @@ func (p *Package) guessKinds(f *File) []*Name { "#line %d \"not-num-const\"\n"+ "void __cgo_f_%d_4(void) { static const double __cgo_undefined__4 = (%s); }\n"+ "#line %d \"not-str-lit\"\n"+ - "void __cgo_f_%d_5(void) { static const char __cgo_undefined__5[] = (%s); }\n"+ - "#line %d \"not-signed-int-const\"\n"+ - "#if 0 < (%s)\n"+ - "#line %d \"not-signed-int-const\"\n"+ - "#error found unsigned int\n"+ - "#endif\n", + "void __cgo_f_%d_5(void) { static const char __cgo_undefined__5[] = (%s); }\n", i+1, i+1, n.C, i+1, i+1, n.C, i+1, i+1, n.C, i+1, i+1, n.C, i+1, i+1, n.C, - i+1, n.C, i+1, ) } fmt.Fprintf(&b, "#line 1 \"completed\"\n"+ @@ -365,7 +353,6 @@ func (p *Package) guessKinds(f *File) []*Name { notNumConst notStrLiteral notDeclared - notSignedIntConst ) sawUnmatchedErrors := false for _, line := range strings.Split(stderr, "\n") { @@ -419,8 +406,6 @@ func (p *Package) guessKinds(f *File) []*Name { sniff[i] |= notNumConst case "not-str-lit": sniff[i] |= notStrLiteral - case "not-signed-int-const": - sniff[i] |= notSignedIntConst default: if isError { sawUnmatchedErrors = true @@ -436,7 +421,7 @@ func (p *Package) guessKinds(f *File) []*Name { } for i, n := range names { - switch sniff[i] &^ notSignedIntConst { + switch sniff[i] { default: var tpos token.Pos for _, ref := range f.Ref { @@ -447,11 +432,7 @@ func (p *Package) guessKinds(f *File) []*Name { } error_(tpos, "could not determine kind of name for C.%s", fixGo(n.Go)) case notStrLiteral | notType: - if sniff[i]¬SignedIntConst != 0 { - n.Kind = "uconst" - } else { - n.Kind = "iconst" - } + n.Kind = "iconst" case notIntConst | notStrLiteral | notType: n.Kind = "fconst" case notIntConst | notNumConst | notType: @@ -496,7 +477,7 @@ func (p *Package) loadDWARF(f *File, names []*Name) { b.WriteString("#line 1 \"cgo-dwarf-inference\"\n") for i, n := range names { fmt.Fprintf(&b, "__typeof__(%s) *__cgo__%d;\n", n.C, i) - if n.Kind == "iconst" || n.Kind == "uconst" { + if n.Kind == "iconst" { fmt.Fprintf(&b, "enum { __cgo_enum__%d = %s };\n", i, n.C) } } @@ -505,7 +486,7 @@ func (p *Package) loadDWARF(f *File, names []*Name) { // so we can read them out of the object file. fmt.Fprintf(&b, "long long __cgodebug_ints[] = {\n") for _, n := range names { - if n.Kind == "iconst" || n.Kind == "uconst" { + if n.Kind == "iconst" { fmt.Fprintf(&b, "\t%s,\n", n.C) } else { fmt.Fprintf(&b, "\t0,\n") @@ -614,11 +595,11 @@ func (p *Package) loadDWARF(f *File, names []*Name) { switch n.Kind { case "iconst": if i < len(ints) { - n.Const = fmt.Sprintf("%#x", ints[i]) - } - case "uconst": - if i < len(ints) { - n.Const = fmt.Sprintf("%#x", uint64(ints[i])) + if _, ok := types[i].(*dwarf.UintType); ok { + n.Const = fmt.Sprintf("%#x", uint64(ints[i])) + } else { + n.Const = fmt.Sprintf("%#x", ints[i]) + } } case "fconst": if i < len(floats) { diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go index 3dc3d141b7..3ad13ef9c7 100644 --- a/src/cmd/cgo/main.go +++ b/src/cmd/cgo/main.go @@ -88,7 +88,7 @@ type Name struct { Mangle string // name used in generated Go C string // name used in C Define string // #define expansion - Kind string // "iconst", "uconst", "fconst", "sconst", "type", "var", "fpvar", "func", "not-type" + Kind string // "iconst", "fconst", "sconst", "type", "var", "fpvar", "func", "not-type" Type *Type // the type of xxx FuncType *FuncType AddError bool @@ -100,7 +100,7 @@ func (n *Name) IsVar() bool { return n.Kind == "var" || n.Kind == "fpvar" } -// IsConst reports whether Kind is either "iconst", "uconst", "fconst" or "sconst" +// IsConst reports whether Kind is either "iconst", "fconst" or "sconst" func (n *Name) IsConst() bool { return strings.HasSuffix(n.Kind, "const") } -- 2.48.1