libgo: update to final Go 1.10 release

    Reviewed-on: https://go-review.googlesource.com/97517

From-SVN: r258051

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 88291d585f9e165432f3a2cfbb3218239d98b0d2..dae8040bccd50e6e6af36ca76dd193644104391b 100644 (file)
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-8b3d6091801d485c74a9c92740c69673e39160b0
+bd7fc3c85d874344b18bbb0a738ec94dfb43794b
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

diff --git a/libgo/MERGE b/libgo/MERGE
index 26b8869db901594eb577bde77d3e3cb12a0977f3..b715f06010bf832377d752890d42cd2b11fc9752 100644 (file)
--- a/libgo/MERGE
+++ b/libgo/MERGE
@@ -1,4 +1,4 @@
-20e228f2fdb44350c858de941dff4aea9f3127b8
+bf86aec25972f3a100c3aa58a6abcbcc35bdea49
 
 The first line of this file holds the git revision number of the
 last merge done from the master library sources.

diff --git a/libgo/VERSION b/libgo/VERSION
index dc3cdca6363558938f9b3dea6f00d2eaa65fffbe..95ec39eb99bde9f63aaf5e20b79a4264b5b80834 100644 (file)
--- a/libgo/VERSION
+++ b/libgo/VERSION
@@ -1 +1 @@
-go1.10rc2
+go1.10

diff --git a/libgo/go/cmd/go/internal/load/pkg.go b/libgo/go/cmd/go/internal/load/pkg.go
index ac764b4d028605f0b74737bae851a0fbf63e3794..52ff6b8fcd29073a5dcf12c13a72a0f018ec9f9a 100644 (file)
--- a/libgo/go/cmd/go/internal/load/pkg.go
+++ b/libgo/go/cmd/go/internal/load/pkg.go
@@ -1224,6 +1224,7 @@ func (p *Package) load(stk *ImportStack, bp *build.Package, err error) {
 // GNU binutils flagfile specifiers, sometimes called "response files").
 // To be conservative, we reject almost any arg beginning with non-alphanumeric ASCII.
 // We accept leading . _ and / as likely in file system paths.
+// There is a copy of this function in cmd/compile/internal/gc/noder.go.
 func SafeArg(name string) bool {
        if name == "" {
                return false

diff --git a/libgo/go/cmd/go/internal/work/exec.go b/libgo/go/cmd/go/internal/work/exec.go
index 5527e90756d38aeda3faf81844a4f1dd10ff2560..40d46023f29b432820a929120649c8aa3456977a 100644 (file)
--- a/libgo/go/cmd/go/internal/work/exec.go
+++ b/libgo/go/cmd/go/internal/work/exec.go
@@ -945,15 +945,20 @@ func splitPkgConfigOutput(out []byte) []string {
 // Calls pkg-config if needed and returns the cflags/ldflags needed to build the package.
 func (b *Builder) getPkgConfigFlags(p *load.Package) (cflags, ldflags []string, err error) {
        if pkgs := p.CgoPkgConfig; len(pkgs) > 0 {
+               var pcflags []string
+               for len(pkgs) > 0 && strings.HasPrefix(pkgs[0], "--") {
+                       pcflags = append(pcflags, pkgs[0])
+                       pkgs = pkgs[1:]
+               }
                for _, pkg := range pkgs {
                        if !load.SafeArg(pkg) {
                                return nil, nil, fmt.Errorf("invalid pkg-config package name: %s", pkg)
                        }
                }
                var out []byte
-               out, err = b.runOut(p.Dir, p.ImportPath, nil, b.PkgconfigCmd(), "--cflags", "--", pkgs)
+               out, err = b.runOut(p.Dir, p.ImportPath, nil, b.PkgconfigCmd(), "--cflags", pcflags, "--", pkgs)
                if err != nil {
-                       b.showOutput(nil, p.Dir, b.PkgconfigCmd()+" --cflags "+strings.Join(pkgs, " "), string(out))
+                       b.showOutput(nil, p.Dir, b.PkgconfigCmd()+" --cflags "+strings.Join(pcflags, " ")+strings.Join(pkgs, " "), string(out))
                        b.Print(err.Error() + "\n")
                        return nil, nil, errPrintedOutput
                }
@@ -963,15 +968,15 @@ func (b *Builder) getPkgConfigFlags(p *load.Package) (cflags, ldflags []string,
                                return nil, nil, err
                        }
                }
-               out, err = b.runOut(p.Dir, p.ImportPath, nil, b.PkgconfigCmd(), "--libs", "--", pkgs)
+               out, err = b.runOut(p.Dir, p.ImportPath, nil, b.PkgconfigCmd(), "--libs", pcflags, "--", pkgs)
                if err != nil {
-                       b.showOutput(nil, p.Dir, b.PkgconfigCmd()+" --libs "+strings.Join(pkgs, " "), string(out))
+                       b.showOutput(nil, p.Dir, b.PkgconfigCmd()+" --libs "+strings.Join(pcflags, " ")+strings.Join(pkgs, " "), string(out))
                        b.Print(err.Error() + "\n")
                        return nil, nil, errPrintedOutput
                }
                if len(out) > 0 {
                        ldflags = strings.Fields(string(out))
-                       if err := checkLinkerFlags("CFLAGS", "pkg-config --cflags", ldflags); err != nil {
+                       if err := checkLinkerFlags("LDFLAGS", "pkg-config --libs", ldflags); err != nil {
                                return nil, nil, err
                        }
                }

diff --git a/libgo/go/cmd/go/internal/work/security.go b/libgo/go/cmd/go/internal/work/security.go
index fee5beeb15f3ea342384770d686814fe7eacba36..54fd6b978201847aef8749db3265f5c1b5c9c506 100644 (file)
--- a/libgo/go/cmd/go/internal/work/security.go
+++ b/libgo/go/cmd/go/internal/work/security.go
@@ -34,6 +34,7 @@ import (
        "fmt"
        "os"
        "regexp"
+       "strings"
 )
 
 var re = regexp.MustCompile
@@ -45,26 +46,42 @@ var validCompilerFlags = []*regexp.Regexp{
        re(`-O([^@\-].*)`),
        re(`-W`),
        re(`-W([^@,]+)`), // -Wall but not -Wa,-foo.
+       re(`-f(no-)?blocks`),
+       re(`-f(no-)?common`),
+       re(`-f(no-)?constant-cfstrings`),
+       re(`-f(no-)?exceptions`),
+       re(`-finput-charset=([^@\-].*)`),
+       re(`-f(no-)?lto`),
+       re(`-f(no-)?modules`),
        re(`-f(no-)?objc-arc`),
        re(`-f(no-)?omit-frame-pointer`),
+       re(`-f(no-)?openmp(-simd)?`),
+       re(`-f(no-)?permissive`),
        re(`-f(no-)?(pic|PIC|pie|PIE)`),
+       re(`-f(no-)?rtti`),
        re(`-f(no-)?split-stack`),
        re(`-f(no-)?stack-(.+)`),
        re(`-f(no-)?strict-aliasing`),
        re(`-fsanitize=(.+)`),
        re(`-g([^@\-].*)?`),
        re(`-m(arch|cpu|fpu|tune)=([^@\-].*)`),
+       re(`-m(no-)?avx[0-9a-z.]*`),
+       re(`-m(no-)?ms-bitfields`),
        re(`-m(no-)?stack-(.+)`),
        re(`-mmacosx-(.+)`),
        re(`-mnop-fun-dllimport`),
+       re(`-m(no-)?sse[0-9.]*`),
+       re(`-pedantic(-errors)?`),
+       re(`-pipe`),
        re(`-pthread`),
-       re(`-std=([^@\-].*)`),
+       re(`-?-std=([^@\-].*)`),
        re(`-x([^@\-].*)`),
 }
 
 var validCompilerFlagsWithNextArg = []string{
        "-D",
        "-I",
+       "-isystem",
        "-framework",
        "-x",
 }
@@ -79,16 +96,29 @@ var validLinkerFlags = []*regexp.Regexp{
        re(`-m(arch|cpu|fpu|tune)=([^@\-].*)`),
        re(`-(pic|PIC|pie|PIE)`),
        re(`-pthread`),
+       re(`-?-static([-a-z0-9+]*)`),
 
        // Note that any wildcards in -Wl need to exclude comma,
        // since -Wl splits its argument at commas and passes
        // them all to the linker uninterpreted. Allowing comma
        // in a wildcard would allow tunnelling arbitrary additional
        // linker arguments through one of these.
+       re(`-Wl,--(no-)?as-needed`),
+       re(`-Wl,-Bdynamic`),
+       re(`-Wl,-Bstatic`),
+       re(`-Wl,--disable-new-dtags`),
+       re(`-Wl,--enable-new-dtags`),
+       re(`-Wl,--end-group`),
+       re(`-Wl,-framework,[^,@\-][^,]+`),
+       re(`-Wl,-headerpad_max_install_names`),
+       re(`-Wl,--no-undefined`),
        re(`-Wl,-rpath,([^,@\-][^,]+)`),
+       re(`-Wl,-search_paths_first`),
+       re(`-Wl,--start-group`),
+       re(`-Wl,-?-unresolved-symbols=[^,]+`),
        re(`-Wl,--(no-)?warn-([^,]+)`),
 
-       re(`[a-zA-Z0-9_].*\.(o|obj|dll|dylib|so)`), // direct linker inputs: x.o or libfoo.so (but not -foo.o or @foo.o)
+       re(`[a-zA-Z0-9_/].*\.(a|o|obj|dll|dylib|so)`), // direct linker inputs: x.o or libfoo.so (but not -foo.o or @foo.o)
 }
 
 var validLinkerFlagsWithNextArg = []string{
@@ -96,6 +126,7 @@ var validLinkerFlagsWithNextArg = []string{
        "-l",
        "-L",
        "-framework",
+       "-Wl,-framework",
 }
 
 func checkCompilerFlags(name, source string, list []string) error {
@@ -147,10 +178,21 @@ Args:
                                        i++
                                        continue Args
                                }
+
+                               // Permit -Wl,-framework -Wl,name.
+                               if i+1 < len(list) &&
+                                       strings.HasPrefix(arg, "-Wl,") &&
+                                       strings.HasPrefix(list[i+1], "-Wl,") &&
+                                       load.SafeArg(list[i+1][4:]) &&
+                                       !strings.Contains(list[i+1][4:], ",") {
+                                       i++
+                                       continue Args
+                               }
+
                                if i+1 < len(list) {
-                                       return fmt.Errorf("invalid flag in %s: %s %s", source, arg, list[i+1])
+                                       return fmt.Errorf("invalid flag in %s: %s %s (see https://golang.org/s/invalidflag)", source, arg, list[i+1])
                                }
-                               return fmt.Errorf("invalid flag in %s: %s without argument", source, arg)
+                               return fmt.Errorf("invalid flag in %s: %s without argument (see https://golang.org/s/invalidflag)", source, arg)
                        }
                }
        Bad:

diff --git a/libgo/go/cmd/go/internal/work/security_test.go b/libgo/go/cmd/go/internal/work/security_test.go
index 739ab5a6ee63b5b82aa3b61633e6e351457c1118..976501b81089069b9223811455362dbc9bcc53af 100644 (file)
--- a/libgo/go/cmd/go/internal/work/security_test.go
+++ b/libgo/go/cmd/go/internal/work/security_test.go
@@ -132,6 +132,9 @@ var goodLinkerFlags = [][]string{
        {"-l", "世界"},
        {"-L", "framework"},
        {"-framework", "Chocolate"},
+       {"-Wl,-framework", "-Wl,Chocolate"},
+       {"-Wl,-framework,Chocolate"},
+       {"-Wl,-unresolved-symbols=ignore-all"},
 }
 
 var badLinkerFlags = [][]string{
@@ -185,6 +188,10 @@ var badLinkerFlags = [][]string{
        {"-l", "-foo"},
        {"-framework", "-Caffeine"},
        {"-framework", "@Home"},
+       {"-Wl,-framework,-Caffeine"},
+       {"-Wl,-framework", "-Wl,@Home"},
+       {"-Wl,-framework", "@Home"},
+       {"-Wl,-framework,Chocolate,@Home"},
        {"-x", "--c"},
        {"-x", "@obj"},
        {"-Wl,-rpath,@foo"},