diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go index a44eff27b8..f6cf86befc 100644 --- a/misc/cgo/test/cgo_test.go +++ b/misc/cgo/test/cgo_test.go @@ -81,5 +81,6 @@ func Test18720(t *testing.T) { test18720(t) } func Test20266(t *testing.T) { test20266(t) } func Test20129(t *testing.T) { test20129(t) } func Test20910(t *testing.T) { test20910(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/doc.go b/src/cmd/cgo/doc.go index cfd09246af..9cd2a42988 100644 --- a/src/cmd/cgo/doc.go +++ b/src/cmd/cgo/doc.go @@ -419,11 +419,6 @@ identifiers C.foo, cgo generates this C program: void __cgo_f_1_4(void) { static const double __cgo_undefined__4 = (foo); } #line 1 "not-str-lit" void __cgo_f_1_5(void) { static const char __cgo_undefined__5[] = (foo); } - #line 1 "not-signed-int-const" - #if 0 < -(foo) - #line 1 "not-signed-int-const" - #error found unsigned int - #endif This program will not compile, but cgo can use the presence or absence of an error message on a given line to deduce the information it diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go index 6cfd83f835..774786405c 100644 --- a/src/cmd/cgo/gcc.go +++ b/src/cmd/cgo/gcc.go @@ -301,18 +301,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. @@ -331,18 +325,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"+ @@ -361,7 +349,6 @@ func (p *Package) guessKinds(f *File) []*Name { notNumConst notStrLiteral notDeclared - notSignedIntConst ) sawUnmatchedErrors := false for _, line := range strings.Split(stderr, "\n") { @@ -415,8 +402,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 @@ -432,15 +417,11 @@ func (p *Package) guessKinds(f *File) []*Name { } for i, n := range names { - switch sniff[i] &^ notSignedIntConst { + switch sniff[i] { default: error_(f.NamePos[n], "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: @@ -485,7 +466,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) } } @@ -494,7 +475,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") @@ -592,11 +573,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 c43985d1bf..2820fc1bfb 100644 --- a/src/cmd/cgo/main.go +++ b/src/cmd/cgo/main.go @@ -89,7 +89,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", "macro", "not-type" + Kind string // "iconst", "fconst", "sconst", "type", "var", "fpvar", "func", "macro", "not-type" Type *Type // the type of xxx FuncType *FuncType AddError bool @@ -101,7 +101,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") }