[dev.ssa] Merge remote-tracking branch 'origin/master' into mergebranch
Semi-regular merge from tip to dev.ssa.
Conflicts:
src/runtime/sys_windows_amd64.s
Change-Id: I5f733130049c810e6ceacd46dad85faebca52b29
diff --git a/src/bootstrap.bash b/src/bootstrap.bash
index 1b5ba7c..7947e84 100755
--- a/src/bootstrap.bash
+++ b/src/bootstrap.bash
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
# Copyright 2015 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.
diff --git a/src/buildall.bash b/src/buildall.bash
index ba23d31..f686dd8 100755
--- a/src/buildall.bash
+++ b/src/buildall.bash
@@ -33,7 +33,7 @@
fi
# put linux, nacl first in the target list to get all the architectures up front.
-targets="$((ls runtime | sed -n 's/^rt0_\(.*\)_\(.*\)\.s/\1-\2/p'; echo linux-386-387 linux-arm-arm5) | sort | egrep -v android-arm | egrep "$pattern" | egrep 'linux|nacl')
+targets="$((ls runtime | sed -n 's/^rt0_\(.*\)_\(.*\)\.s/\1-\2/p'; echo linux-386-387 linux-arm-arm5) | sort | sed -e 's|linux-mips64x|linux-mips64 linux-mips64le|' | egrep -v android-arm | egrep "$pattern" | egrep 'linux|nacl')
$(ls runtime | sed -n 's/^rt0_\(.*\)_\(.*\)\.s/\1-\2/p' | egrep -v 'android-arm|darwin-arm' | egrep "$pattern" | egrep -v 'linux|nacl')"
./make.bash || exit 1
diff --git a/src/cmd/cgo/doc.go b/src/cmd/cgo/doc.go
index 8ec4301..bd38a5c 100644
--- a/src/cmd/cgo/doc.go
+++ b/src/cmd/cgo/doc.go
@@ -125,11 +125,19 @@
To access a struct, union, or enum type directly, prefix it with
struct_, union_, or enum_, as in C.struct_stat.
+The size of any C type T is available as C.sizeof_T, as in
+C.sizeof_struct_stat.
+
As Go doesn't have support for C's union type in the general case,
C's union types are represented as a Go byte array with the same length.
Go structs cannot embed fields with C types.
+Go code can not refer to zero-sized fields that occur at the end of
+non-empty C structs. To get the address of such a field (which is the
+only operation you can do with a zero-sized field) you must take the
+address of the struct and add the size of the struct.
+
Cgo translates C types into equivalent unexported Go types.
Because the translations are unexported, a Go package should not
expose C types in its exported API: a C type used in one Go package
diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go
index 750b89b..fb5049c 100644
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -626,9 +626,7 @@
// Add optional additional arguments for an address
// expression.
- if u, ok := call.Args[i].(*ast.UnaryExpr); ok && u.Op == token.AND {
- c.Args = p.checkAddrArgs(f, c.Args, u.X)
- }
+ c.Args = p.checkAddrArgs(f, c.Args, call.Args[i])
// _cgoCheckPointer returns interface{}.
// We need to type assert that to the type we want.
@@ -773,7 +771,19 @@
// only pass the slice or array if we can refer to it without side
// effects.
func (p *Package) checkAddrArgs(f *File, args []ast.Expr, x ast.Expr) []ast.Expr {
- index, ok := x.(*ast.IndexExpr)
+ // Strip type conversions.
+ for {
+ c, ok := x.(*ast.CallExpr)
+ if !ok || len(c.Args) != 1 || !p.isType(c.Fun) {
+ break
+ }
+ x = c.Args[0]
+ }
+ u, ok := x.(*ast.UnaryExpr)
+ if !ok || u.Op != token.AND {
+ return args
+ }
+ index, ok := u.X.(*ast.IndexExpr)
if !ok {
// This is the address of something that is not an
// index expression. We only need to examine the
@@ -804,6 +814,42 @@
return found
}
+// isType returns whether the expression is definitely a type.
+// This is conservative--it returns false for an unknown identifier.
+func (p *Package) isType(t ast.Expr) bool {
+ switch t := t.(type) {
+ case *ast.SelectorExpr:
+ if t.Sel.Name != "Pointer" {
+ return false
+ }
+ id, ok := t.X.(*ast.Ident)
+ if !ok {
+ return false
+ }
+ return id.Name == "unsafe"
+ case *ast.Ident:
+ // TODO: This ignores shadowing.
+ switch t.Name {
+ case "unsafe.Pointer", "bool", "byte",
+ "complex64", "complex128",
+ "error",
+ "float32", "float64",
+ "int", "int8", "int16", "int32", "int64",
+ "rune", "string",
+ "uint", "uint8", "uint16", "uint32", "uint64", "uintptr":
+
+ return true
+ }
+ case *ast.StarExpr:
+ return p.isType(t.X)
+ case *ast.ArrayType, *ast.StructType, *ast.FuncType, *ast.InterfaceType,
+ *ast.MapType, *ast.ChanType:
+
+ return true
+ }
+ return false
+}
+
// unsafeCheckPointerName is given the Go version of a C type. If the
// type uses unsafe.Pointer, we arrange to build a version of
// _cgoCheckPointer that returns that type. This avoids using a type
@@ -832,6 +878,8 @@
func (p *Package) hasUnsafePointer(t ast.Expr) bool {
switch t := t.(type) {
case *ast.Ident:
+ // We don't see a SelectorExpr for unsafe.Pointer;
+ // this is created by code in this file.
return t.Name == "unsafe.Pointer"
case *ast.ArrayType:
return p.hasUnsafePointer(t.Elt)
diff --git a/src/cmd/compile/internal/amd64/prog.go b/src/cmd/compile/internal/amd64/prog.go
index b4cc781..b43dde6 100644
--- a/src/cmd/compile/internal/amd64/prog.go
+++ b/src/cmd/compile/internal/amd64/prog.go
@@ -34,6 +34,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Intel opcode.
diff --git a/src/cmd/compile/internal/arm/peep.go b/src/cmd/compile/internal/arm/peep.go
index d7a9c5f..bc49ebc 100644
--- a/src/cmd/compile/internal/arm/peep.go
+++ b/src/cmd/compile/internal/arm/peep.go
@@ -1366,6 +1366,7 @@
obj.AFUNCDATA,
obj.AVARDEF,
obj.AVARKILL,
+ obj.AVARLIVE,
obj.AUSEFIELD:
return 0
}
diff --git a/src/cmd/compile/internal/arm/prog.go b/src/cmd/compile/internal/arm/prog.go
index 8a304e2..81be77a 100644
--- a/src/cmd/compile/internal/arm/prog.go
+++ b/src/cmd/compile/internal/arm/prog.go
@@ -33,6 +33,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Intel opcode.
diff --git a/src/cmd/compile/internal/arm64/peep.go b/src/cmd/compile/internal/arm64/peep.go
index b61ac6e..daa626f 100644
--- a/src/cmd/compile/internal/arm64/peep.go
+++ b/src/cmd/compile/internal/arm64/peep.go
@@ -711,6 +711,7 @@
obj.AFUNCDATA,
obj.AVARDEF,
obj.AVARKILL,
+ obj.AVARLIVE,
obj.AUSEFIELD:
return 0
}
diff --git a/src/cmd/compile/internal/arm64/prog.go b/src/cmd/compile/internal/arm64/prog.go
index a4b8ebe..a8e8bc5 100644
--- a/src/cmd/compile/internal/arm64/prog.go
+++ b/src/cmd/compile/internal/arm64/prog.go
@@ -34,6 +34,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Power opcode.
diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index d30515a..795b53d 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -634,6 +634,7 @@
var wr int
var v Val
var norig *Node
+ var nn *Node
if nr == nil {
// copy numeric value to avoid modifying
// nl, in case someone still refers to it (e.g. iota).
@@ -1115,15 +1116,21 @@
return
settrue:
- norig = saveorig(n)
- *n = *Nodbool(true)
- n.Orig = norig
+ nn = Nodbool(true)
+ nn.Orig = saveorig(n)
+ if !iscmp[n.Op] {
+ nn.Type = nl.Type
+ }
+ *n = *nn
return
setfalse:
- norig = saveorig(n)
- *n = *Nodbool(false)
- n.Orig = norig
+ nn = Nodbool(false)
+ nn.Orig = saveorig(n)
+ if !iscmp[n.Op] {
+ nn.Type = nl.Type
+ }
+ *n = *nn
return
illegal:
diff --git a/src/cmd/compile/internal/gc/esc.go b/src/cmd/compile/internal/gc/esc.go
index 293f916..ff983e7 100644
--- a/src/cmd/compile/internal/gc/esc.go
+++ b/src/cmd/compile/internal/gc/esc.go
@@ -299,12 +299,13 @@
}
type NodeEscState struct {
- Curfn *Node
- Escflowsrc *NodeList // flow(this, src)
- Escretval *NodeList // on OCALLxxx, list of dummy return values
- Escloopdepth int32 // -1: global, 0: return variables, 1:function top level, increased inside function for every loop or label to mark scopes
- Esclevel Level
- Walkgen uint32
+ Curfn *Node
+ Escflowsrc *NodeList // flow(this, src)
+ Escretval *NodeList // on OCALLxxx, list of dummy return values
+ Escloopdepth int32 // -1: global, 0: return variables, 1:function top level, increased inside function for every loop or label to mark scopes
+ Esclevel Level
+ Walkgen uint32
+ Maxextraloopdepth int32
}
func (e *EscState) nodeEscState(n *Node) *NodeEscState {
@@ -1579,7 +1580,13 @@
src.Op == ONAME && src.Class == PPARAM && src.Name.Curfn == dst.Name.Curfn
}
+const NOTALOOPDEPTH = -1
+
func escwalk(e *EscState, level Level, dst *Node, src *Node) {
+ escwalkBody(e, level, dst, src, NOTALOOPDEPTH)
+}
+
+func escwalkBody(e *EscState, level Level, dst *Node, src *Node, extraloopdepth int32) {
if src.Op == OLITERAL {
return
}
@@ -1590,16 +1597,29 @@
// convergence.
level = level.min(srcE.Esclevel)
if level == srcE.Esclevel {
- return
+ // Have we been here already with an extraloopdepth,
+ // or is the extraloopdepth provided no improvement on
+ // what's already been seen?
+ if srcE.Maxextraloopdepth >= extraloopdepth || srcE.Escloopdepth >= extraloopdepth {
+ return
+ }
+ srcE.Maxextraloopdepth = extraloopdepth
}
+ } else { // srcE.Walkgen < e.walkgen -- first time, reset this.
+ srcE.Maxextraloopdepth = NOTALOOPDEPTH
}
srcE.Walkgen = e.walkgen
srcE.Esclevel = level
+ modSrcLoopdepth := srcE.Escloopdepth
+
+ if extraloopdepth > modSrcLoopdepth {
+ modSrcLoopdepth = extraloopdepth
+ }
if Debug['m'] > 1 {
- fmt.Printf("escwalk: level:%d depth:%d %.*s op=%v %v(%v) scope:%v[%d]\n",
- level, e.pdepth, e.pdepth, "\t\t\t\t\t\t\t\t\t\t", Oconv(int(src.Op), 0), Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), e.curfnSym(src), srcE.Escloopdepth)
+ fmt.Printf("escwalk: level:%d depth:%d %.*s op=%v %v(%v) scope:%v[%d] extraloopdepth=%v\n",
+ level, e.pdepth, e.pdepth, "\t\t\t\t\t\t\t\t\t\t", Oconv(int(src.Op), 0), Nconv(src, obj.FmtShort), Jconv(src, obj.FmtShort), e.curfnSym(src), srcE.Escloopdepth, extraloopdepth)
}
e.pdepth++
@@ -1638,7 +1658,7 @@
}
}
- leaks = level.int() <= 0 && level.guaranteedDereference() <= 0 && dstE.Escloopdepth < srcE.Escloopdepth
+ leaks = level.int() <= 0 && level.guaranteedDereference() <= 0 && dstE.Escloopdepth < modSrcLoopdepth
switch src.Op {
case ONAME:
@@ -1650,7 +1670,7 @@
Warnl(int(src.Lineno), "leaking param content: %v", Nconv(src, obj.FmtShort))
} else {
Warnl(int(src.Lineno), "leaking param content: %v level=%v dst.eld=%v src.eld=%v dst=%v",
- Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, srcE.Escloopdepth, Nconv(dst, obj.FmtShort))
+ Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth, Nconv(dst, obj.FmtShort))
}
}
} else {
@@ -1660,7 +1680,7 @@
Warnl(int(src.Lineno), "leaking param: %v", Nconv(src, obj.FmtShort))
} else {
Warnl(int(src.Lineno), "leaking param: %v level=%v dst.eld=%v src.eld=%v dst=%v",
- Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, srcE.Escloopdepth, Nconv(dst, obj.FmtShort))
+ Nconv(src, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth, Nconv(dst, obj.FmtShort))
}
}
}
@@ -1686,15 +1706,17 @@
}
if Debug['m'] > 1 {
Warnl(int(src.Lineno), "%v escapes to heap, level=%v, dst.eld=%v, src.eld=%v",
- Nconv(p, obj.FmtShort), level, dstE.Escloopdepth, srcE.Escloopdepth)
+ Nconv(p, obj.FmtShort), level, dstE.Escloopdepth, modSrcLoopdepth)
} else {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(p, obj.FmtShort))
}
}
+ escwalkBody(e, level.dec(), dst, src.Left, modSrcLoopdepth)
+ extraloopdepth = modSrcLoopdepth // passes to recursive case, seems likely a no-op
+ } else {
+ escwalk(e, level.dec(), dst, src.Left)
}
- escwalk(e, level.dec(), dst, src.Left)
-
case OAPPEND:
escwalk(e, level, dst, src.List.N)
@@ -1704,6 +1726,7 @@
if Debug['m'] != 0 {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
}
+ extraloopdepth = modSrcLoopdepth
}
// similar to a slice arraylit and its args.
level = level.dec()
@@ -1737,6 +1760,7 @@
if Debug['m'] != 0 {
Warnl(int(src.Lineno), "%v escapes to heap", Nconv(src, obj.FmtShort))
}
+ extraloopdepth = modSrcLoopdepth
}
case ODOT,
@@ -1778,12 +1802,19 @@
recurse:
level = level.copy()
for ll := srcE.Escflowsrc; ll != nil; ll = ll.Next {
- escwalk(e, level, dst, ll.N)
+ escwalkBody(e, level, dst, ll.N, extraloopdepth)
}
e.pdepth--
}
+// This special tag is applied to uintptr variables
+// that we believe may hold unsafe.Pointers for
+// calls into assembly functions.
+// It is logically a constant, but using a var
+// lets us take the address below to get a *string.
+var unsafeUintptrTag = "unsafe-uintptr"
+
func esctag(e *EscState, func_ *Node) {
func_.Esc = EscFuncTagged
@@ -1798,6 +1829,29 @@
}
}
+ // Assume that uintptr arguments must be held live across the call.
+ // This is most important for syscall.Syscall.
+ // See golang.org/issue/13372.
+ // This really doesn't have much to do with escape analysis per se,
+ // but we are reusing the ability to annotate an individual function
+ // argument and pass those annotations along to importing code.
+ narg := 0
+ for t := getinargx(func_.Type).Type; t != nil; t = t.Down {
+ narg++
+ if t.Type.Etype == TUINTPTR {
+ if Debug['m'] != 0 {
+ var name string
+ if t.Sym != nil {
+ name = t.Sym.Name
+ } else {
+ name = fmt.Sprintf("arg#%d", narg)
+ }
+ Warnl(int(func_.Lineno), "%v assuming %v is unsafe uintptr", funcSym(func_), name)
+ }
+ t.Note = &unsafeUintptrTag
+ }
+ }
+
return
}
diff --git a/src/cmd/compile/internal/gc/float_test.go b/src/cmd/compile/internal/gc/float_test.go
new file mode 100644
index 0000000..c761e96
--- /dev/null
+++ b/src/cmd/compile/internal/gc/float_test.go
@@ -0,0 +1,102 @@
+// Copyright 2016 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 gc
+
+import "testing"
+
+// For GO386=387, make sure fucomi* opcodes are not used
+// for comparison operations.
+// Note that this test will fail only on a Pentium MMX
+// processor (with GOARCH=386 GO386=387), as it just runs
+// some code and looks for an unimplemented instruction fault.
+
+//go:noinline
+func compare1(a, b float64) bool {
+ return a < b
+}
+
+//go:noinline
+func compare2(a, b float32) bool {
+ return a < b
+}
+
+func TestFloatCompare(t *testing.T) {
+ if !compare1(3, 5) {
+ t.Errorf("compare1 returned false")
+ }
+ if !compare2(3, 5) {
+ t.Errorf("compare2 returned false")
+ }
+}
+
+// For GO386=387, make sure fucomi* opcodes are not used
+// for float->int conversions.
+
+//go:noinline
+func cvt1(a float64) uint64 {
+ return uint64(a)
+}
+
+//go:noinline
+func cvt2(a float64) uint32 {
+ return uint32(a)
+}
+
+//go:noinline
+func cvt3(a float32) uint64 {
+ return uint64(a)
+}
+
+//go:noinline
+func cvt4(a float32) uint32 {
+ return uint32(a)
+}
+
+//go:noinline
+func cvt5(a float64) int64 {
+ return int64(a)
+}
+
+//go:noinline
+func cvt6(a float64) int32 {
+ return int32(a)
+}
+
+//go:noinline
+func cvt7(a float32) int64 {
+ return int64(a)
+}
+
+//go:noinline
+func cvt8(a float32) int32 {
+ return int32(a)
+}
+
+func TestFloatConvert(t *testing.T) {
+ if got := cvt1(3.5); got != 3 {
+ t.Errorf("cvt1 got %d, wanted 3", got)
+ }
+ if got := cvt2(3.5); got != 3 {
+ t.Errorf("cvt2 got %d, wanted 3", got)
+ }
+ if got := cvt3(3.5); got != 3 {
+ t.Errorf("cvt3 got %d, wanted 3", got)
+ }
+ if got := cvt4(3.5); got != 3 {
+ t.Errorf("cvt4 got %d, wanted 3", got)
+ }
+ if got := cvt5(3.5); got != 3 {
+ t.Errorf("cvt5 got %d, wanted 3", got)
+ }
+ if got := cvt6(3.5); got != 3 {
+ t.Errorf("cvt6 got %d, wanted 3", got)
+ }
+ if got := cvt7(3.5); got != 3 {
+ t.Errorf("cvt7 got %d, wanted 3", got)
+ }
+ if got := cvt8(3.5); got != 3 {
+ t.Errorf("cvt8 got %d, wanted 3", got)
+ }
+}
diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index c9208d9..ac55d4f 100644
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -607,6 +607,9 @@
n.Esc = EscNever
n.Name.Curfn = Curfn
Curfn.Func.Dcl = list(Curfn.Func.Dcl, n)
+ if Debug['h'] != 0 {
+ println("H", n, n.Orig, funcSym(Curfn).Name)
+ }
dowidth(t)
n.Xoffset = 0
@@ -870,6 +873,9 @@
case OVARKILL:
gvarkill(n.Left)
+
+ case OVARLIVE:
+ gvarlive(n.Left)
}
ret:
diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index f17a701..be0a0fb 100644
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -185,7 +185,7 @@
continue
}
- if (p.As == obj.AVARDEF || p.As == obj.AVARKILL) && p.To.Node != nil && !((p.To.Node).(*Node)).Used {
+ if (p.As == obj.AVARDEF || p.As == obj.AVARKILL || p.As == obj.AVARLIVE) && p.To.Node != nil && !((p.To.Node).(*Node)).Used {
// Cannot remove VARDEF instruction, because - unlike TYPE handled above -
// VARDEFs are interspersed with other code, and a jump might be using the
// VARDEF as a target. Replace with a no-op instead. A later pass will remove
diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index 830c56d..fb30d58 100644
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -694,7 +694,13 @@
errorexit()
}
- if f.U.(string) == "unsafe" {
+ path_ := f.U.(string)
+
+ if mapped, ok := importMap[path_]; ok {
+ path_ = mapped
+ }
+
+ if path_ == "unsafe" {
if safemode != 0 {
Yyerror("cannot import package unsafe")
errorexit()
@@ -706,12 +712,6 @@
return
}
- path_ := f.U.(string)
-
- if mapped, ok := importMap[path_]; ok {
- path_ = mapped
- }
-
if islocalname(path_) {
if path_[0] == '/' {
Yyerror("import path cannot be absolute path")
diff --git a/src/cmd/compile/internal/gc/order.go b/src/cmd/compile/internal/gc/order.go
index 84b96c2d..05cd53a 100644
--- a/src/cmd/compile/internal/gc/order.go
+++ b/src/cmd/compile/internal/gc/order.go
@@ -243,6 +243,13 @@
var kill *Node
for l := order.temp; l != mark; l = l.Next {
+ if l.N.Name.Keepalive {
+ l.N.Name.Keepalive = false
+ l.N.Addrtaken = true // ensure SSA keeps the l.N variable
+ kill = Nod(OVARLIVE, l.N, nil)
+ typecheck(&kill, Etop)
+ *out = list(*out, kill)
+ }
kill = Nod(OVARKILL, l.N, nil)
typecheck(&kill, Etop)
*out = list(*out, kill)
@@ -375,6 +382,28 @@
orderexpr(&n.Left, order, nil)
orderexpr(&n.Right, order, nil) // ODDDARG temp
ordercallargs(&n.List, order)
+
+ if n.Op == OCALLFUNC {
+ for l, t := n.List, getinargx(n.Left.Type).Type; l != nil && t != nil; l, t = l.Next, t.Down {
+ // Check for "unsafe-uintptr" tag provided by escape analysis.
+ // If present and the argument is really a pointer being converted
+ // to uintptr, arrange for the pointer to be kept alive until the call
+ // returns, by copying it into a temp and marking that temp
+ // still alive when we pop the temp stack.
+ if t.Note != nil && *t.Note == unsafeUintptrTag {
+ xp := &l.N
+ for (*xp).Op == OCONVNOP && !Isptr[(*xp).Type.Etype] {
+ xp = &(*xp).Left
+ }
+ x := *xp
+ if Isptr[x.Type.Etype] {
+ x = ordercopyexpr(x, x.Type, order, 0)
+ x.Name.Keepalive = true
+ *xp = x
+ }
+ }
+ }
+ }
}
// Ordermapassign appends n to order->out, introducing temporaries
@@ -464,7 +493,7 @@
default:
Fatalf("orderstmt %v", Oconv(int(n.Op), 0))
- case OVARKILL:
+ case OVARKILL, OVARLIVE:
order.out = list(order.out, n)
case OAS:
diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 9b65f9c..6e7e10e 100644
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -95,7 +95,11 @@
switch n.Class {
case PAUTO, PPARAM, PPARAMOUT:
- Thearch.Gins(as, nil, n)
+ if as == obj.AVARLIVE {
+ Thearch.Gins(as, n, nil)
+ } else {
+ Thearch.Gins(as, nil, n)
+ }
}
}
@@ -107,13 +111,17 @@
gvardefx(n, obj.AVARKILL)
}
+func gvarlive(n *Node) {
+ gvardefx(n, obj.AVARLIVE)
+}
+
func removevardef(firstp *obj.Prog) {
for p := firstp; p != nil; p = p.Link {
- for p.Link != nil && (p.Link.As == obj.AVARDEF || p.Link.As == obj.AVARKILL) {
+ for p.Link != nil && (p.Link.As == obj.AVARDEF || p.Link.As == obj.AVARKILL || p.Link.As == obj.AVARLIVE) {
p.Link = p.Link.Link
}
if p.To.Type == obj.TYPE_BRANCH {
- for p.To.Val.(*obj.Prog) != nil && (p.To.Val.(*obj.Prog).As == obj.AVARDEF || p.To.Val.(*obj.Prog).As == obj.AVARKILL) {
+ for p.To.Val.(*obj.Prog) != nil && (p.To.Val.(*obj.Prog).As == obj.AVARDEF || p.To.Val.(*obj.Prog).As == obj.AVARKILL || p.To.Val.(*obj.Prog).As == obj.AVARLIVE) {
p.To.Val = p.To.Val.(*obj.Prog).Link
}
}
diff --git a/src/cmd/compile/internal/gc/plive.go b/src/cmd/compile/internal/gc/plive.go
index 7765d2d..458497d 100644
--- a/src/cmd/compile/internal/gc/plive.go
+++ b/src/cmd/compile/internal/gc/plive.go
@@ -809,7 +809,7 @@
return
}
- fmt.Printf("checkauto %v: %v (%p; class=%d) not found in %v\n", Curfn, n, n, n.Class, p)
+ fmt.Printf("checkauto %v: %v (%p; class=%d) not found in %p %v\n", funcSym(Curfn), n, n, n.Class, p, p)
for l := fn.Func.Dcl; l != nil; l = l.Next {
fmt.Printf("\t%v (%p; class=%d)\n", l.N, l.N, l.N.Class)
}
diff --git a/src/cmd/compile/internal/gc/racewalk.go b/src/cmd/compile/internal/gc/racewalk.go
index 5f35c44..ee4f3ba 100644
--- a/src/cmd/compile/internal/gc/racewalk.go
+++ b/src/cmd/compile/internal/gc/racewalk.go
@@ -143,7 +143,7 @@
goto ret
// can't matter
- case OCFUNC, OVARKILL:
+ case OCFUNC, OVARKILL, OVARLIVE:
goto ret
case OBLOCK:
diff --git a/src/cmd/compile/internal/gc/reg.go b/src/cmd/compile/internal/gc/reg.go
index f575094..14dc03b 100644
--- a/src/cmd/compile/internal/gc/reg.go
+++ b/src/cmd/compile/internal/gc/reg.go
@@ -1073,6 +1073,9 @@
for f := firstf; f != nil; f = f.Link {
p := f.Prog
+ // AVARLIVE must be considered a use, do not skip it.
+ // Otherwise the variable will be optimized away,
+ // and the whole point of AVARLIVE is to keep it on the stack.
if p.As == obj.AVARDEF || p.As == obj.AVARKILL {
continue
}
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 46aaaa7..be9af60 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -849,6 +849,13 @@
s.vars[&memVar] = s.newValue1A(ssa.OpVarKill, ssa.TypeMem, n.Left, s.mem())
}
+ case OVARLIVE:
+ // Insert a varlive op to record that a variable is still live.
+ if !n.Left.Addrtaken {
+ s.Fatalf("VARLIVE variable %s must have Addrtaken set", n.Left)
+ }
+ s.vars[&memVar] = s.newValue1A(ssa.OpVarLive, ssa.TypeMem, n.Left, s.mem())
+
case OCHECKNIL:
p := s.expr(n.Left)
s.nilCheck(p)
@@ -4122,6 +4129,8 @@
Gvardef(v.Aux.(*Node))
case ssa.OpVarKill:
gvarkill(v.Aux.(*Node))
+ case ssa.OpVarLive:
+ gvarlive(v.Aux.(*Node))
case ssa.OpAMD64LoweredNilCheck:
// Optimization - if the subsequent block has a load or store
// at the same address, we don't need to issue this instruction.
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index da23e05..b97cb3f 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -128,6 +128,7 @@
Captured bool // is the variable captured by a closure
Byval bool // is the variable captured by value or by reference
Needzero bool // if it contains pointers, needs to be zeroed on function entry
+ Keepalive bool // mark value live across unknown assembly call
}
type Param struct {
@@ -342,6 +343,7 @@
OCFUNC // reference to c function pointer (not go func value)
OCHECKNIL // emit code to ensure pointer/interface not nil
OVARKILL // variable is dead
+ OVARLIVE // variable is alive
// thearch-specific registers
OREGISTER // a register, such as AX.
diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 2244802..f74bb33 100644
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -687,8 +687,6 @@
n.Left = l
n.Right = r
}
- } else if n.Op == OANDAND || n.Op == OOROR {
- evconst(n)
}
if et == TSTRING {
@@ -2025,7 +2023,8 @@
OEMPTY,
OGOTO,
OXFALL,
- OVARKILL:
+ OVARKILL,
+ OVARLIVE:
ok |= Etop
break OpSwitch
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 838def9..dddcb68 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -216,7 +216,8 @@
ODCLCONST,
ODCLTYPE,
OCHECKNIL,
- OVARKILL:
+ OVARKILL,
+ OVARLIVE:
break
case OBLOCK:
diff --git a/src/cmd/compile/internal/mips64/peep.go b/src/cmd/compile/internal/mips64/peep.go
index 3d82c81..f97be60 100644
--- a/src/cmd/compile/internal/mips64/peep.go
+++ b/src/cmd/compile/internal/mips64/peep.go
@@ -688,6 +688,7 @@
obj.AFUNCDATA,
obj.AVARDEF,
obj.AVARKILL,
+ obj.AVARLIVE,
obj.AUSEFIELD:
return 0
}
diff --git a/src/cmd/compile/internal/mips64/prog.go b/src/cmd/compile/internal/mips64/prog.go
index bf13d82..b07c7fe 100644
--- a/src/cmd/compile/internal/mips64/prog.go
+++ b/src/cmd/compile/internal/mips64/prog.go
@@ -34,6 +34,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the MIPS opcode.
diff --git a/src/cmd/compile/internal/ppc64/peep.go b/src/cmd/compile/internal/ppc64/peep.go
index fadaa4a..1ff3109 100644
--- a/src/cmd/compile/internal/ppc64/peep.go
+++ b/src/cmd/compile/internal/ppc64/peep.go
@@ -953,6 +953,7 @@
obj.AFUNCDATA,
obj.AVARDEF,
obj.AVARKILL,
+ obj.AVARLIVE,
obj.AUSEFIELD:
return 0
}
diff --git a/src/cmd/compile/internal/ppc64/prog.go b/src/cmd/compile/internal/ppc64/prog.go
index 92293be..6b48256 100644
--- a/src/cmd/compile/internal/ppc64/prog.go
+++ b/src/cmd/compile/internal/ppc64/prog.go
@@ -34,6 +34,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Power opcode.
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index e57dd93..d17f558 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -373,6 +373,7 @@
{name: "VarDef", typ: "Mem"}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem
{name: "VarKill"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem
+ {name: "VarLive"}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem
}
// kind control successors implicit exit
diff --git a/src/cmd/compile/internal/ssa/lower.go b/src/cmd/compile/internal/ssa/lower.go
index 1b50eb6..af0ee4c 100644
--- a/src/cmd/compile/internal/ssa/lower.go
+++ b/src/cmd/compile/internal/ssa/lower.go
@@ -21,7 +21,7 @@
continue // lowered
}
switch v.Op {
- case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill:
+ case OpSP, OpSB, OpInitMem, OpArg, OpPhi, OpVarDef, OpVarKill, OpVarLive:
continue // ok not to lower
}
s := "not lowered: " + v.Op.String() + " " + v.Type.SimpleString()
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 2fd7f6b..433794a 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -552,6 +552,7 @@
OpFwdRef
OpVarDef
OpVarKill
+ OpVarLive
)
var opcodeTable = [...]opInfo{
@@ -4310,6 +4311,10 @@
name: "VarKill",
generic: true,
},
+ {
+ name: "VarLive",
+ generic: true,
+ },
}
func (o Op) Asm() int { return opcodeTable[o].asm }
diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index e559a9f..139b199 100644
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -764,9 +764,7 @@
gc.Cgen(nr, &tmp)
gc.Cgen(nl, &tmp)
}
-
- gins(x86.AFUCOMIP, &tmp, &n2)
- gins(x86.AFMOVDP, &tmp, &tmp) // annoying pop but still better than STSW+SAHF
+ gins(x86.AFUCOMPP, &tmp, &n2)
} else {
// TODO(rsc): The moves back and forth to memory
// here are for truncating the value to 32 bits.
@@ -783,9 +781,9 @@
gc.Cgen(nl, &t2)
gmove(&t2, &tmp)
gins(x86.AFCOMFP, &t1, &tmp)
- gins(x86.AFSTSW, nil, &ax)
- gins(x86.ASAHF, nil, nil)
}
+ gins(x86.AFSTSW, nil, &ax)
+ gins(x86.ASAHF, nil, nil)
} else {
// Not 387
if !nl.Addable {
diff --git a/src/cmd/compile/internal/x86/gsubr.go b/src/cmd/compile/internal/x86/gsubr.go
index 0397857..9859571 100644
--- a/src/cmd/compile/internal/x86/gsubr.go
+++ b/src/cmd/compile/internal/x86/gsubr.go
@@ -1198,14 +1198,17 @@
// if 0 > v { answer = 0 }
gins(x86.AFMOVD, &zerof, &f0)
-
- gins(x86.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMP, &f0, &f1)
+ gins(x86.AFSTSW, nil, &ax)
+ gins(x86.ASAHF, nil, nil)
p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
// if 1<<64 <= v { answer = 0 too }
gins(x86.AFMOVD, &two64f, &f0)
- gins(x86.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMP, &f0, &f1)
+ gins(x86.AFSTSW, nil, &ax)
+ gins(x86.ASAHF, nil, nil)
p2 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
gc.Patch(p1, gc.Pc)
gins(x86.AFMOVVP, &f0, t) // don't care about t, but will pop the stack
@@ -1235,7 +1238,9 @@
// actual work
gins(x86.AFMOVD, &two63f, &f0)
- gins(x86.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMP, &f0, &f1)
+ gins(x86.AFSTSW, nil, &ax)
+ gins(x86.ASAHF, nil, nil)
p2 = gc.Gbranch(optoas(gc.OLE, gc.Types[tt]), nil, 0)
gins(x86.AFMOVVP, &f0, t)
p3 := gc.Gbranch(obj.AJMP, nil, 0)
diff --git a/src/cmd/compile/internal/x86/prog.go b/src/cmd/compile/internal/x86/prog.go
index 465a21f..3399a28 100644
--- a/src/cmd/compile/internal/x86/prog.go
+++ b/src/cmd/compile/internal/x86/prog.go
@@ -40,6 +40,7 @@
obj.ACHECKNIL: {Flags: gc.LeftRead},
obj.AVARDEF: {Flags: gc.Pseudo | gc.RightWrite},
obj.AVARKILL: {Flags: gc.Pseudo | gc.RightWrite},
+ obj.AVARLIVE: {Flags: gc.Pseudo | gc.LeftRead},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Intel opcode.
@@ -91,8 +92,12 @@
x86.AFCOMDPP: {Flags: gc.SizeD | gc.LeftAddr | gc.RightRead},
x86.AFCOMF: {Flags: gc.SizeF | gc.LeftAddr | gc.RightRead},
x86.AFCOMFP: {Flags: gc.SizeF | gc.LeftAddr | gc.RightRead},
- x86.AFUCOMIP: {Flags: gc.SizeF | gc.LeftAddr | gc.RightRead},
- x86.AFCHS: {Flags: gc.SizeD | RightRdwr}, // also SizeF
+ // NOTE(khr): don't use FUCOMI* instructions, not available
+ // on Pentium MMX. See issue 13923.
+ //x86.AFUCOMIP: {Flags: gc.SizeF | gc.LeftAddr | gc.RightRead},
+ x86.AFUCOMP: {Flags: gc.SizeD | gc.LeftRead | gc.RightRead},
+ x86.AFUCOMPP: {Flags: gc.SizeD | gc.LeftRead | gc.RightRead},
+ x86.AFCHS: {Flags: gc.SizeD | RightRdwr}, // also SizeF
x86.AFDIVDP: {Flags: gc.SizeD | gc.LeftAddr | RightRdwr},
x86.AFDIVF: {Flags: gc.SizeF | gc.LeftAddr | RightRdwr},
diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 679c23b..4cd696a 100644
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -656,7 +656,7 @@
case "c-shared":
switch pair {
case "linux-386", "linux-amd64", "linux-arm", "linux-arm64",
- "darwin-amd64",
+ "darwin-amd64", "darwin-386",
"android-arm", "android-arm64", "android-386":
return true
}
@@ -913,6 +913,12 @@
s = "DYLD_LIBRARY_PATH"
}
cmd.Env = mergeEnvLists([]string{s + "=."}, os.Environ())
+
+ // On FreeBSD 64-bit architectures, the 32-bit linker looks for
+ // different environment variables.
+ if t.goos == "freebsd" && t.gohostarch == "386" {
+ cmd.Env = mergeEnvLists([]string{"LD_32_LIBRARY_PATH=."}, cmd.Env)
+ }
}
return cmd.Run()
}
diff --git a/src/cmd/dist/util.go b/src/cmd/dist/util.go
index 1b42954..1b5d1f9 100644
--- a/src/cmd/dist/util.go
+++ b/src/cmd/dist/util.go
@@ -461,7 +461,7 @@
}
}
- if gohostarch == "arm" {
+ if gohostarch == "arm" || gohostarch == "mips64" || gohostarch == "mips64le" {
maxbg = min(maxbg, runtime.NumCPU())
}
bginit()
diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 6c6d551..6a8edaf 100644
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -354,7 +354,7 @@
case "linux/amd64", "linux/arm", "linux/arm64", "linux/386",
"android/amd64", "android/arm", "android/arm64", "android/386":
codegenArg = "-shared"
- case "darwin/amd64":
+ case "darwin/amd64", "darwin/386":
default:
fatalf("-buildmode=c-shared not supported on %s\n", platform)
}
@@ -822,7 +822,9 @@
pkg := new(Package)
pkg.local = true
pkg.cmdline = true
+ stk.push("main")
pkg.load(&stk, bp, err)
+ stk.pop()
pkg.localPrefix = dirToImportPath(dir)
pkg.ImportPath = "command-line-arguments"
pkg.target = ""
@@ -999,13 +1001,22 @@
// Install header for cgo in c-archive and c-shared modes.
if p.usesCgo() && (buildBuildmode == "c-archive" || buildBuildmode == "c-shared") {
+ hdrTarget := a.target[:len(a.target)-len(filepath.Ext(a.target))] + ".h"
+ if buildContext.Compiler == "gccgo" {
+ // For the header file, remove the "lib"
+ // added by go/build, so we generate pkg.h
+ // rather than libpkg.h.
+ dir, file := filepath.Split(hdrTarget)
+ file = strings.TrimPrefix(file, "lib")
+ hdrTarget = filepath.Join(dir, file)
+ }
ah := &action{
p: a.p,
deps: []*action{a.deps[0]},
f: (*builder).installHeader,
pkgdir: a.pkgdir,
objdir: a.objdir,
- target: a.target[:len(a.target)-len(filepath.Ext(a.target))] + ".h",
+ target: hdrTarget,
}
a.deps = append(a.deps, ah)
}
@@ -2711,6 +2722,10 @@
// libffi.
ldflags = append(ldflags, "-Wl,-r", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive")
+ if b.gccSupportsNoPie() {
+ ldflags = append(ldflags, "-no-pie")
+ }
+
// We are creating an object file, so we don't want a build ID.
ldflags = b.disableBuildID(ldflags)
@@ -2718,7 +2733,7 @@
out = out + ".o"
case "c-shared":
- ldflags = append(ldflags, "-shared", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive", "-lgo", "-lgcc_s", "-lgcc")
+ ldflags = append(ldflags, "-shared", "-nostdlib", "-Wl,--whole-archive", "-lgolibbegin", "-Wl,--no-whole-archive", "-lgo", "-lgcc_s", "-lgcc", "-lc", "-lgcc")
default:
fatalf("-buildmode=%s not supported for gccgo", ldBuildmode)
@@ -2902,6 +2917,36 @@
return a
}
+// On systems with PIE (position independent executables) enabled by default,
+// -no-pie must be passed when doing a partial link with -Wl,-r. But -no-pie is
+// not supported by all compilers.
+func (b *builder) gccSupportsNoPie() bool {
+ if goos != "linux" {
+ // On some BSD platforms, error messages from the
+ // compiler make it to the console despite cmd.Std*
+ // all being nil. As -no-pie is only required on linux
+ // systems so far, we only test there.
+ return false
+ }
+ src := filepath.Join(b.work, "trivial.c")
+ if err := ioutil.WriteFile(src, []byte{}, 0666); err != nil {
+ return false
+ }
+ cmdArgs := b.gccCmd(b.work)
+ cmdArgs = append(cmdArgs, "-no-pie", "-c", "trivial.c")
+ if buildN || buildX {
+ b.showcmd(b.work, "%s", joinUnambiguously(cmdArgs))
+ if buildN {
+ return false
+ }
+ }
+ cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
+ cmd.Dir = b.work
+ cmd.Env = envForDir(cmd.Dir, os.Environ())
+ out, err := cmd.CombinedOutput()
+ return err == nil && !bytes.Contains(out, []byte("unrecognized"))
+}
+
// gccArchArgs returns arguments to pass to gcc based on the architecture.
func (b *builder) gccArchArgs() []string {
switch goarch {
@@ -3158,6 +3203,10 @@
}
ldflags := stringList(bareLDFLAGS, "-Wl,-r", "-nostdlib", staticLibs)
+ if b.gccSupportsNoPie() {
+ ldflags = append(ldflags, "-no-pie")
+ }
+
// We are creating an object file, so we don't want a build ID.
ldflags = b.disableBuildID(ldflags)
diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index cc36b43..50c7521 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -961,6 +961,16 @@
tg.grepBoth("use of internal package not allowed", "wrote error message for testdata/testinternal2")
}
+func TestRunInternal(t *testing.T) {
+ tg := testgo(t)
+ defer tg.cleanup()
+ dir := filepath.Join(tg.pwd(), "testdata")
+ tg.setenv("GOPATH", dir)
+ tg.run("run", filepath.Join(dir, "src/run/good.go"))
+ tg.runFail("run", filepath.Join(dir, "src/run/bad.go"))
+ tg.grepStderr("use of internal package not allowed", "unexpected error for run/bad.go")
+}
+
func testMove(t *testing.T, vcs, url, base, config string) {
testenv.MustHaveExternalNetwork(t)
diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index 3361fc3..0507841 100644
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -348,11 +348,9 @@
// TODO: After Go 1, decide when to pass build.AllowBinary here.
// See issue 3268 for mistakes to avoid.
buildMode := build.ImportComment
- if go15VendorExperiment && mode&useVendor != 0 && path == origPath {
- // We've already searched the vendor directories and didn't find anything.
- // Let Import search them again so that, if the package is not found anywhere,
- // the error includes the vendor directories in the list of places considered.
- buildMode |= build.AllowVendor
+ if !go15VendorExperiment || mode&useVendor == 0 || path != origPath {
+ // Not vendoring, or we already found the vendored path.
+ buildMode |= build.IgnoreVendor
}
bp, err := buildContext.Import(path, srcDir, buildMode)
bp.ImportPath = importPath
@@ -422,7 +420,7 @@
continue
}
targ := filepath.Join(dir[:i], vpath)
- if isDir(targ) {
+ if isDir(targ) && hasGoFiles(targ) {
// We started with parent's dir c:\gopath\src\foo\bar\baz\quux\xyzzy.
// We know the import path for parent's dir.
// We chopped off some number of path elements and
@@ -445,6 +443,20 @@
return path
}
+// hasGoFiles reports whether dir contains any files with names ending in .go.
+// For a vendor check we must exclude directories that contain no .go files.
+// Otherwise it is not possible to vendor just a/b/c and still import the
+// non-vendored a/b. See golang.org/issue/13832.
+func hasGoFiles(dir string) bool {
+ fis, _ := ioutil.ReadDir(dir)
+ for _, fi := range fis {
+ if !fi.IsDir() && strings.HasSuffix(fi.Name(), ".go") {
+ return true
+ }
+ }
+ return false
+}
+
// reusePackage reuses package p to satisfy the import at the top
// of the import stack stk. If this use causes an import loop,
// reusePackage updates p's error information to record the loop.
@@ -504,7 +516,7 @@
i-- // rewind over slash in ".../internal"
}
parent := p.Dir[:i+len(p.Dir)-len(p.ImportPath)]
- if hasPathPrefix(filepath.ToSlash(srcDir), filepath.ToSlash(parent)) {
+ if hasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
return p
}
@@ -601,7 +613,7 @@
return p
}
parent := p.Dir[:truncateTo]
- if hasPathPrefix(filepath.ToSlash(srcDir), filepath.ToSlash(parent)) {
+ if hasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
return p
}
diff --git a/src/cmd/go/testdata/src/run/bad.go b/src/cmd/go/testdata/src/run/bad.go
new file mode 100644
index 0000000..c1cc3ac
--- /dev/null
+++ b/src/cmd/go/testdata/src/run/bad.go
@@ -0,0 +1,5 @@
+package main
+
+import _ "run/subdir/internal/private"
+
+func main() {}
diff --git a/src/cmd/go/testdata/src/run/good.go b/src/cmd/go/testdata/src/run/good.go
new file mode 100644
index 0000000..0b67dce
--- /dev/null
+++ b/src/cmd/go/testdata/src/run/good.go
@@ -0,0 +1,5 @@
+package main
+
+import _ "run/internal"
+
+func main() {}
diff --git a/src/cmd/go/testdata/src/run/internal/internal.go b/src/cmd/go/testdata/src/run/internal/internal.go
new file mode 100644
index 0000000..5bf0569
--- /dev/null
+++ b/src/cmd/go/testdata/src/run/internal/internal.go
@@ -0,0 +1 @@
+package internal
diff --git a/src/cmd/go/testdata/src/run/subdir/internal/private/private.go b/src/cmd/go/testdata/src/run/subdir/internal/private/private.go
new file mode 100644
index 0000000..735e4dc
--- /dev/null
+++ b/src/cmd/go/testdata/src/run/subdir/internal/private/private.go
@@ -0,0 +1 @@
+package private
diff --git a/src/cmd/go/testdata/src/vend/dir1/dir1.go b/src/cmd/go/testdata/src/vend/dir1/dir1.go
new file mode 100644
index 0000000..b719ead
--- /dev/null
+++ b/src/cmd/go/testdata/src/vend/dir1/dir1.go
@@ -0,0 +1 @@
+package dir1
diff --git a/src/cmd/go/testdata/src/vend/vendor/vend/dir1/dir2/dir2.go b/src/cmd/go/testdata/src/vend/vendor/vend/dir1/dir2/dir2.go
new file mode 100644
index 0000000..6fe35e9
--- /dev/null
+++ b/src/cmd/go/testdata/src/vend/vendor/vend/dir1/dir2/dir2.go
@@ -0,0 +1 @@
+package dir2
diff --git a/src/cmd/go/testdata/src/vend/x/x.go b/src/cmd/go/testdata/src/vend/x/x.go
index ae526eb..bdcde57 100644
--- a/src/cmd/go/testdata/src/vend/x/x.go
+++ b/src/cmd/go/testdata/src/vend/x/x.go
@@ -3,3 +3,5 @@
import _ "p"
import _ "q"
import _ "r"
+import _ "vend/dir1" // not vendored
+import _ "vend/dir1/dir2" // vendored
diff --git a/src/cmd/go/vendor_test.go b/src/cmd/go/vendor_test.go
index ed73be3..006a8c9 100644
--- a/src/cmd/go/vendor_test.go
+++ b/src/cmd/go/vendor_test.go
@@ -24,12 +24,14 @@
tg.run("list", "-f", "{{.ImportPath}} {{.Imports}}", "vend/...")
want := `
vend [vend/vendor/p r]
+ vend/dir1 []
vend/hello [fmt vend/vendor/strings]
vend/subdir [vend/vendor/p r]
vend/vendor/p []
vend/vendor/q []
vend/vendor/strings []
- vend/x [vend/x/vendor/p vend/vendor/q vend/x/vendor/r]
+ vend/vendor/vend/dir1/dir2 []
+ vend/x [vend/x/vendor/p vend/vendor/q vend/x/vendor/r vend/dir1 vend/vendor/vend/dir1/dir2]
vend/x/invalid [vend/x/invalid/vendor/foo]
vend/x/vendor/p []
vend/x/vendor/p/p [notfound]
@@ -45,6 +47,14 @@
}
}
+func TestVendorBuild(t *testing.T) {
+ tg := testgo(t)
+ defer tg.cleanup()
+ tg.setenv("GOPATH", filepath.Join(tg.pwd(), "testdata"))
+ tg.setenv("GO15VENDOREXPERIMENT", "1")
+ tg.run("build", "vend/x")
+}
+
func TestVendorRun(t *testing.T) {
tg := testgo(t)
defer tg.cleanup()
diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index 511e409..bc89823 100644
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -282,6 +282,7 @@
AUSEFIELD
AVARDEF
AVARKILL
+ AVARLIVE
A_ARCHSPECIFIC
)
@@ -609,6 +610,12 @@
Version int
Textp *LSym
Etextp *LSym
+
+ // state for writing objects
+ Text *LSym
+ Data *LSym
+ Etext *LSym
+ Edata *LSym
}
// The smallest possible offset from the hardware stack pointer to a local
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index 13930aa..8d4a506 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -111,6 +111,11 @@
// out a Go object file. The linker does not call this; the linker
// does not write out object files.
func Writeobjdirect(ctxt *Link, b *Biobuf) {
+ Flushplist(ctxt)
+ Writeobjfile(ctxt, b)
+}
+
+func Flushplist(ctxt *Link) {
var flag int
var s *LSym
var p *Prog
@@ -119,13 +124,11 @@
// Build list of symbols, and assign instructions to lists.
// Ignore ctxt->plist boundaries. There are no guarantees there,
- // and the C compilers and assemblers just use one big list.
- var text *LSym
-
+ // and the assemblers just use one big list.
var curtext *LSym
- var data *LSym
+ var text *LSym
var etext *LSym
- var edata *LSym
+
for pl := ctxt.Plist; pl != nil; pl = pl.Link {
for p = pl.Firstpc; p != nil; p = plink {
if ctxt.Debugasm != 0 && ctxt.Debugvlog != 0 {
@@ -174,10 +177,10 @@
log.Fatalf("symbol %s listed multiple times", s.Name)
}
s.Onlist = 1
- if data == nil {
- data = s
+ if ctxt.Data == nil {
+ ctxt.Data = s
} else {
- edata.Next = s
+ ctxt.Edata.Next = s
}
s.Next = nil
s.Size = p.To.Offset
@@ -195,7 +198,7 @@
} else if flag&TLSBSS != 0 {
s.Type = STLSBSS
}
- edata = s
+ ctxt.Edata = s
continue
}
@@ -298,6 +301,17 @@
linkpcln(ctxt, s)
}
+ // Add to running list in ctxt.
+ if ctxt.Etext == nil {
+ ctxt.Text = text
+ } else {
+ ctxt.Etext.Next = text
+ }
+ ctxt.Etext = etext
+ ctxt.Plist = nil
+}
+
+func Writeobjfile(ctxt *Link, b *Biobuf) {
// Emit header.
Bputc(b, 0)
@@ -312,10 +326,10 @@
wrstring(b, "")
// Emit symbols.
- for s := text; s != nil; s = s.Next {
+ for s := ctxt.Text; s != nil; s = s.Next {
writesym(ctxt, b, s)
}
- for s := data; s != nil; s = s.Next {
+ for s := ctxt.Data; s != nil; s = s.Next {
writesym(ctxt, b, s)
}
diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index 5846470..ea59d46 100644
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -611,7 +611,7 @@
}
func Aconv(a int) string {
- if a < A_ARCHSPECIFIC {
+ if 0 <= a && a < len(Anames) {
return Anames[a]
}
for i := range aSpace {
@@ -643,6 +643,7 @@
"USEFIELD",
"VARDEF",
"VARKILL",
+ "VARLIVE",
}
func Bool2int(b bool) int {
diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index 244aa15..4ee8cfb 100644
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -181,6 +181,7 @@
APAUSE
APOPAL
APOPAW
+ APOPCNT
APOPFL
APOPFW
APOPL
@@ -500,6 +501,7 @@
AXADDQ
AXCHGQ
AXORQ
+ AXGETBV
// media
AADDPD
@@ -614,6 +616,9 @@
APCMPGTL
APCMPGTW
APEXTRW
+ APEXTRB
+ APEXTRD
+ APEXTRQ
APFACC
APFADD
APFCMPEQ
@@ -632,6 +637,7 @@
APFSUB
APFSUBR
APINSRW
+ APINSRB
APINSRD
APINSRQ
APMADDWL
diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go
index 9eb57b0..392899c 100644
--- a/src/cmd/internal/obj/x86/anames.go
+++ b/src/cmd/internal/obj/x86/anames.go
@@ -149,6 +149,7 @@
"PAUSE",
"POPAL",
"POPAW",
+ "POPCNT",
"POPFL",
"POPFW",
"POPL",
@@ -451,6 +452,7 @@
"XADDQ",
"XCHGQ",
"XORQ",
+ "XGETBV",
"ADDPD",
"ADDPS",
"ADDSD",
@@ -563,6 +565,9 @@
"PCMPGTL",
"PCMPGTW",
"PEXTRW",
+ "PEXTRB",
+ "PEXTRD",
+ "PEXTRQ",
"PFACC",
"PFADD",
"PFCMPEQ",
@@ -581,6 +586,7 @@
"PFSUB",
"PFSUBR",
"PINSRW",
+ "PINSRB",
"PINSRD",
"PINSRQ",
"PMADDWL",
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 8bb4dff..164dbd6 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -187,6 +187,7 @@
Zm_r_xm_nr
Zr_m_xm_nr
Zibm_r /* mmx1,mmx2/mem64,imm8 */
+ Zibr_m
Zmb_r
Zaut_r
Zo_m
@@ -219,6 +220,7 @@
Pf2 = 0xf2 /* xmm escape 1: f2 0f */
Pf3 = 0xf3 /* xmm escape 2: f3 0f */
Pq3 = 0x67 /* xmm escape 3: 66 48 0f */
+ Pfw = 0xf4 /* Pf3 with Rex.w: f3 48 0f */
Pvex1 = 0xc5 /* 66.0f escape, vex encoding */
Pvex2 = 0xc6 /* f3.0f escape, vex encoding */
Pvex3 = 0xc7 /* 66.0f38 escape, vex encoding */
@@ -720,6 +722,10 @@
{Yu8, Yxr, Yrl, Zibm_r, 2},
}
+var yextr = []ytab{
+ {Yu8, Yxr, Ymm, Zibr_m, 3},
+}
+
var yinsrw = []ytab{
{Yu8, Yml, Yxr, Zibm_r, 2},
}
@@ -1162,6 +1168,9 @@
{APCMPGTL, ymm, Py1, [23]uint8{0x66, Pe, 0x66}},
{APCMPGTW, ymm, Py1, [23]uint8{0x65, Pe, 0x65}},
{APEXTRW, yextrw, Pq, [23]uint8{0xc5, 00}},
+ {APEXTRB, yextr, Pq, [23]uint8{0x3a, 0x14, 00}},
+ {APEXTRD, yextr, Pq, [23]uint8{0x3a, 0x16, 00}},
+ {APEXTRQ, yextr, Pq3, [23]uint8{0x3a, 0x16, 00}},
{APF2IL, ymfp, Px, [23]uint8{0x1d}},
{APF2IW, ymfp, Px, [23]uint8{0x1c}},
{API2FL, ymfp, Px, [23]uint8{0x0d}},
@@ -1183,6 +1192,7 @@
{APFSUB, ymfp, Px, [23]uint8{0x9a}},
{APFSUBR, ymfp, Px, [23]uint8{0xaa}},
{APINSRW, yinsrw, Pq, [23]uint8{0xc4, 00}},
+ {APINSRB, yinsr, Pq, [23]uint8{0x3a, 0x20, 00}},
{APINSRD, yinsr, Pq, [23]uint8{0x3a, 0x22, 00}},
{APINSRQ, yinsr, Pq3, [23]uint8{0x3a, 0x22, 00}},
{APMADDWL, ymm, Py1, [23]uint8{0xf5, Pe, 0xf5}},
@@ -1198,6 +1208,7 @@
{APMULULQ, ymm, Py1, [23]uint8{0xf4, Pe, 0xf4}},
{APOPAL, ynone, P32, [23]uint8{0x61}},
{APOPAW, ynone, Pe, [23]uint8{0x61}},
+ {APOPCNT, yml_rl, Pfw, [23]uint8{0xb8}},
{APOPFL, ynone, P32, [23]uint8{0x9d}},
{APOPFQ, ynone, Py, [23]uint8{0x9d}},
{APOPFW, ynone, Pe, [23]uint8{0x9d}},
@@ -1533,6 +1544,7 @@
{AXABORT, yxabort, Px, [23]uint8{0xc6, 0xf8}},
{AXEND, ynone, Px, [23]uint8{0x0f, 01, 0xd5}},
{AXTEST, ynone, Px, [23]uint8{0x0f, 01, 0xd6}},
+ {AXGETBV, ynone, Pm, [23]uint8{01, 0xd0}},
{obj.AUSEFIELD, ynop, Px, [23]uint8{0, 0}},
{obj.ATYPE, nil, 0, [23]uint8{}},
{obj.AFUNCDATA, yfuncdata, Px, [23]uint8{0, 0}},
@@ -3194,6 +3206,15 @@
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
+ case Pfw: /* first escape, Rex.w, and second escape */
+ ctxt.Andptr[0] = Pf3
+ ctxt.Andptr = ctxt.Andptr[1:]
+
+ ctxt.Andptr[0] = Pw
+ ctxt.Andptr = ctxt.Andptr[1:]
+ ctxt.Andptr[0] = Pm
+ ctxt.Andptr = ctxt.Andptr[1:]
+
case Pm: /* opcode escape */
ctxt.Andptr[0] = Pm
ctxt.Andptr = ctxt.Andptr[1:]
@@ -3343,7 +3364,7 @@
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
- case Zibm_r:
+ case Zibm_r, Zibr_m:
for {
tmp1 := z
z++
@@ -3354,7 +3375,11 @@
ctxt.Andptr[0] = byte(op)
ctxt.Andptr = ctxt.Andptr[1:]
}
- asmand(ctxt, p, p.From3, &p.To)
+ if yt.zcase == Zibr_m {
+ asmand(ctxt, p, &p.To, p.From3)
+ } else {
+ asmand(ctxt, p, p.From3, &p.To)
+ }
ctxt.Andptr[0] = byte(p.From.Offset)
ctxt.Andptr = ctxt.Andptr[1:]
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 5bb206a..7561250 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1068,7 +1068,7 @@
argv = append(argv, "-pie")
case BuildmodeCShared:
if HEADTYPE == obj.Hdarwin {
- argv = append(argv, "-dynamiclib")
+ argv = append(argv, "-dynamiclib", "-Wl,-read_only_relocs,suppress")
} else {
// ELF.
argv = append(argv, "-Wl,-Bsymbolic")
diff --git a/src/cmd/link/internal/ld/macho.go b/src/cmd/link/internal/ld/macho.go
index af93361..1c7f3a0 100644
--- a/src/cmd/link/internal/ld/macho.go
+++ b/src/cmd/link/internal/ld/macho.go
@@ -566,6 +566,25 @@
}
}
+ if Linkmode == LinkInternal {
+ // For lldb, must say LC_VERSION_MIN_MACOSX or else
+ // it won't know that this Mach-O binary is from OS X
+ // (could be iOS or WatchOS intead).
+ // Go on iOS uses linkmode=external, and linkmode=external
+ // adds this itself. So we only need this code for linkmode=internal
+ // and we can assume OS X.
+ //
+ // See golang.org/issues/12941.
+ const (
+ LC_VERSION_MIN_MACOSX = 0x24
+ LC_VERSION_MIN_IPHONEOS = 0x25
+ LC_VERSION_MIN_WATCHOS = 0x30
+ )
+ ml := newMachoLoad(LC_VERSION_MIN_MACOSX, 2)
+ ml.data[0] = 10<<16 | 7<<8 | 0<<0 // OS X version 10.7.0
+ ml.data[1] = 10<<16 | 7<<8 | 0<<0 // SDK 10.7.0
+ }
+
// TODO: dwarf headers go in ms too
if Debug['s'] == 0 {
dwarfaddmachoheaders(ms)
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index 16ce7bd..00fbb17 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -1217,12 +1217,17 @@
// larger size, as verified with VMMap.
// Go code would be OK with 64k stacks, but we need larger stacks for cgo.
- // That default stack reserve size affects only the main thread,
- // for other threads we specify stack size in runtime explicitly
+ //
+ // The default stack reserve size affects only the main
+ // thread, ctrlhandler thread, and profileloop thread. For
+ // these, it must be greater than the stack size assumed by
+ // externalthreadhandler.
+ //
+ // For other threads we specify stack size in runtime explicitly
// (runtime knows whether cgo is enabled or not).
- // If you change stack reserve sizes here,
- // change STACKSIZE in runtime/cgo/gcc_windows_{386,amd64}.c and correspondent
- // CreateThread parameter in runtime.newosproc as well.
+ // For these, the reserve must match STACKSIZE in
+ // runtime/cgo/gcc_windows_{386,amd64}.c and the correspondent
+ // CreateThread parameter in runtime.newosproc.
if !iscgo {
oh64.SizeOfStackReserve = 0x00020000
oh.SizeOfStackReserve = 0x00020000
diff --git a/src/crypto/aes/asm_amd64.s b/src/crypto/aes/asm_amd64.s
index 6a6e6ac..b257998 100644
--- a/src/crypto/aes/asm_amd64.s
+++ b/src/crypto/aes/asm_amd64.s
@@ -217,8 +217,6 @@
MOVUPS X0, 16(DX)
RET
-#define PSHUFD_X0_X0_ BYTE $0x66; BYTE $0x0f; BYTE $0x70; BYTE $0xc0
-#define PSHUFD_X1_X1_ BYTE $0x66; BYTE $0x0f; BYTE $0x70; BYTE $0xc9
TEXT _expand_key_128<>(SB),NOSPLIT,$0
PSHUFD $0xff, X1, X1
SHUFPS $0x10, X0, X4
@@ -230,8 +228,6 @@
ADDQ $16, BX
RET
-#define PSLLDQ_X5_ BYTE $0x66; BYTE $0x0f; BYTE $0x73; BYTE $0xfd
-#define PSHUFD_X0_X3_ BYTE $0x66; BYTE $0x0f; BYTE $0x70; BYTE $0xd8
TEXT _expand_key_192a<>(SB),NOSPLIT,$0
PSHUFD $0x55, X1, X1
SHUFPS $0x10, X0, X4
@@ -242,7 +238,7 @@
MOVAPS X2, X5
MOVAPS X2, X6
- PSLLDQ_X5_; BYTE $0x4
+ PSLLDQ $0x4, X5
PSHUFD $0xff, X0, X3
PXOR X3, X2
PXOR X5, X2
@@ -264,7 +260,7 @@
PXOR X1, X0
MOVAPS X2, X5
- PSLLDQ_X5_; BYTE $0x4
+ PSLLDQ $0x4, X5
PSHUFD $0xff, X0, X3
PXOR X3, X2
PXOR X5, X2
diff --git a/src/crypto/aes/gcm_amd64.s b/src/crypto/aes/gcm_amd64.s
index f60c92d..cabb028 100644
--- a/src/crypto/aes/gcm_amd64.s
+++ b/src/crypto/aes/gcm_amd64.s
@@ -345,7 +345,7 @@
PXOR B0, B0
MOVQ (aut), B0
PINSRD $2, 8(aut), B0
- BYTE $0x66; BYTE $0x0f; BYTE $0x3a; BYTE $0x20; BYTE $0x46; BYTE $0x0c; BYTE $0x0c //PINSRB $12, 12(aut), B0
+ PINSRB $12, 12(aut), B0
XORQ autLen, autLen
JMP dataMul
@@ -404,7 +404,7 @@
dataLoadLoop:
PSLLDQ $1, B0
- BYTE $0x66; BYTE $0x0f; BYTE $0x3a; BYTE $0x20; BYTE $0x06; BYTE $0x00 //PINSRB $0, (aut), B0
+ PINSRB $0, (aut), B0
LEAQ -1(aut), aut
DECQ autLen
@@ -892,7 +892,7 @@
PXOR B0, B0
ptxLoadLoop:
PSLLDQ $1, B0
- BYTE $0x66; BYTE $0x0f; BYTE $0x3a; BYTE $0x20; BYTE $0x06; BYTE $0x00 //PINSRB $0, (ptx), B0
+ PINSRB $0, (ptx), B0
LEAQ -1(ptx), ptx
DECQ ptxLen
JNE ptxLoadLoop
@@ -1264,7 +1264,7 @@
PXOR T1, B0
ptxStoreLoop:
- BYTE $0x66; BYTE $0x0f; BYTE $0x3a; BYTE $0x14; BYTE $0x06; BYTE $0x00 // PEXTRB $0, B0, (ptx)
+ PEXTRB $0, B0, (ptx)
PSRLDQ $1, B0
LEAQ 1(ptx), ptx
DECQ ptxLen
diff --git a/src/crypto/cipher/gcm.go b/src/crypto/cipher/gcm.go
index 5f18f8c..3868d71 100644
--- a/src/crypto/cipher/gcm.go
+++ b/src/crypto/cipher/gcm.go
@@ -38,6 +38,9 @@
//
// The ciphertext and dst may alias exactly or not at all. To reuse
// ciphertext's storage for the decrypted output, use ciphertext[:0] as dst.
+ //
+ // Even if the function fails, the contents of dst, up to its capacity,
+ // may be overwritten.
Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error)
}
@@ -168,11 +171,19 @@
var expectedTag [gcmTagSize]byte
g.auth(expectedTag[:], ciphertext, data, &tagMask)
+ ret, out := sliceForAppend(dst, len(ciphertext))
+
if subtle.ConstantTimeCompare(expectedTag[:], tag) != 1 {
+ // The AESNI code decrypts and authenticates concurrently, and
+ // so overwrites dst in the event of a tag mismatch. That
+ // behaviour is mimicked here in order to be consistent across
+ // platforms.
+ for i := range out {
+ out[i] = 0
+ }
return nil, errOpen
}
- ret, out := sliceForAppend(dst, len(ciphertext))
g.counterCrypt(out, ciphertext, &counter)
return ret, nil
diff --git a/src/crypto/cipher/gcm_test.go b/src/crypto/cipher/gcm_test.go
index 904091e..bb1ab3c 100644
--- a/src/crypto/cipher/gcm_test.go
+++ b/src/crypto/cipher/gcm_test.go
@@ -240,3 +240,37 @@
ct[0] ^= 0x80
}
}
+
+func TestTagFailureOverwrite(t *testing.T) {
+ // The AESNI GCM code decrypts and authenticates concurrently and so
+ // overwrites the output buffer before checking the authentication tag.
+ // In order to be consistent across platforms, all implementations
+ // should do this and this test checks that.
+
+ key, _ := hex.DecodeString("ab72c77b97cb5fe9a382d9fe81ffdbed")
+ nonce, _ := hex.DecodeString("54cc7dc2c37ec006bcc6d1db")
+ ciphertext, _ := hex.DecodeString("0e1bde206a07a9c2c1b65300f8c649972b4401346697138c7a4891ee59867d0c")
+
+ aes, _ := aes.NewCipher(key)
+ aesgcm, _ := cipher.NewGCM(aes)
+
+ dst := make([]byte, len(ciphertext)-16)
+ for i := range dst {
+ dst[i] = 42
+ }
+
+ result, err := aesgcm.Open(dst[:0], nonce, ciphertext, nil)
+ if err == nil {
+ t.Fatal("Bad Open still resulted in nil error.")
+ }
+
+ if result != nil {
+ t.Fatal("Failed Open returned non-nil result.")
+ }
+
+ for i := range dst {
+ if dst[i] != 0 {
+ t.Fatal("Failed Open didn't zero dst buffer")
+ }
+ }
+}
diff --git a/src/crypto/tls/conn.go b/src/crypto/tls/conn.go
index 115b6c6..0377568 100644
--- a/src/crypto/tls/conn.go
+++ b/src/crypto/tls/conn.go
@@ -16,6 +16,7 @@
"io"
"net"
"sync"
+ "sync/atomic"
"time"
)
@@ -56,6 +57,11 @@
input *block // application data waiting to be read
hand bytes.Buffer // handshake data waiting to be read
+ // activeCall is an atomic int32; the low bit is whether Close has
+ // been called. the rest of the bits are the number of goroutines
+ // in Conn.Write.
+ activeCall int32
+
tmp [16]byte
}
@@ -855,8 +861,22 @@
return m, nil
}
+var errClosed = errors.New("crypto/tls: use of closed connection")
+
// Write writes data to the connection.
func (c *Conn) Write(b []byte) (int, error) {
+ // interlock with Close below
+ for {
+ x := atomic.LoadInt32(&c.activeCall)
+ if x&1 != 0 {
+ return 0, errClosed
+ }
+ if atomic.CompareAndSwapInt32(&c.activeCall, x, x+2) {
+ defer atomic.AddInt32(&c.activeCall, -2)
+ break
+ }
+ }
+
if err := c.Handshake(); err != nil {
return 0, err
}
@@ -960,6 +980,27 @@
// Close closes the connection.
func (c *Conn) Close() error {
+ // Interlock with Conn.Write above.
+ var x int32
+ for {
+ x = atomic.LoadInt32(&c.activeCall)
+ if x&1 != 0 {
+ return errClosed
+ }
+ if atomic.CompareAndSwapInt32(&c.activeCall, x, x|1) {
+ break
+ }
+ }
+ if x != 0 {
+ // io.Writer and io.Closer should not be used concurrently.
+ // If Close is called while a Write is currently in-flight,
+ // interpret that as a sign that this Close is really just
+ // being used to break the Write and/or clean up resources and
+ // avoid sending the alertCloseNotify, which may block
+ // waiting on handshakeMutex or the c.out mutex.
+ return c.conn.Close()
+ }
+
var alertErr error
c.handshakeMutex.Lock()
diff --git a/src/crypto/tls/tls_test.go b/src/crypto/tls/tls_test.go
index 6b5d455..5cc14278 100644
--- a/src/crypto/tls/tls_test.go
+++ b/src/crypto/tls/tls_test.go
@@ -6,6 +6,7 @@
import (
"bytes"
+ "errors"
"fmt"
"internal/testenv"
"io"
@@ -364,3 +365,104 @@
c.Close()
}
}
+
+func TestConnCloseBreakingWrite(t *testing.T) {
+ ln := newLocalListener(t)
+ defer ln.Close()
+
+ srvCh := make(chan *Conn, 1)
+ var serr error
+ var sconn net.Conn
+ go func() {
+ var err error
+ sconn, err = ln.Accept()
+ if err != nil {
+ serr = err
+ srvCh <- nil
+ return
+ }
+ serverConfig := *testConfig
+ srv := Server(sconn, &serverConfig)
+ if err := srv.Handshake(); err != nil {
+ serr = fmt.Errorf("handshake: %v", err)
+ srvCh <- nil
+ return
+ }
+ srvCh <- srv
+ }()
+
+ cconn, err := net.Dial("tcp", ln.Addr().String())
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer cconn.Close()
+
+ conn := &changeImplConn{
+ Conn: cconn,
+ }
+
+ clientConfig := *testConfig
+ tconn := Client(conn, &clientConfig)
+ if err := tconn.Handshake(); err != nil {
+ t.Fatal(err)
+ }
+
+ srv := <-srvCh
+ if srv == nil {
+ t.Fatal(serr)
+ }
+ defer sconn.Close()
+
+ connClosed := make(chan struct{})
+ conn.closeFunc = func() error {
+ close(connClosed)
+ return nil
+ }
+
+ inWrite := make(chan bool, 1)
+ var errConnClosed = errors.New("conn closed for test")
+ conn.writeFunc = func(p []byte) (n int, err error) {
+ inWrite <- true
+ <-connClosed
+ return 0, errConnClosed
+ }
+
+ closeReturned := make(chan bool, 1)
+ go func() {
+ <-inWrite
+ tconn.Close() // test that this doesn't block forever.
+ closeReturned <- true
+ }()
+
+ _, err = tconn.Write([]byte("foo"))
+ if err != errConnClosed {
+ t.Errorf("Write error = %v; want errConnClosed", err)
+ }
+
+ <-closeReturned
+ if err := tconn.Close(); err != errClosed {
+ t.Errorf("Close error = %v; want errClosed", err)
+ }
+}
+
+// changeImplConn is a net.Conn which can change its Write and Close
+// methods.
+type changeImplConn struct {
+ net.Conn
+ writeFunc func([]byte) (int, error)
+ closeFunc func() error
+}
+
+func (w *changeImplConn) Write(p []byte) (n int, err error) {
+ if w.writeFunc != nil {
+ return w.writeFunc(p)
+ }
+ return w.Conn.Write(p)
+}
+
+func (w *changeImplConn) Close() error {
+ if w.closeFunc != nil {
+ return w.closeFunc()
+ }
+ return w.Conn.Close()
+}
diff --git a/src/database/sql/driver/types.go b/src/database/sql/driver/types.go
index 3305354..bc54784 100644
--- a/src/database/sql/driver/types.go
+++ b/src/database/sql/driver/types.go
@@ -200,10 +200,15 @@
// ValueConverter that's used when a Stmt doesn't implement
// ColumnConverter.
//
-// DefaultParameterConverter returns the given value directly if
-// IsValue(value). Otherwise integer type are converted to
-// int64, floats to float64, and strings to []byte. Other types are
-// an error.
+// DefaultParameterConverter returns its argument directly if
+// IsValue(arg). Otherwise, if the argument implements Valuer, its
+// Value method is used to return a Value. As a fallback, the provided
+// argument's underlying type is used to convert it to a Value:
+// underlying integer types are converted to int64, floats to float64,
+// and strings to []byte. If the argument is a nil pointer,
+// ConvertValue returns a nil Value. If the argument is a non-nil
+// pointer, it is dereferenced and ConvertValue is called
+// recursively. Other types are an error.
var DefaultParameterConverter defaultConverter
type defaultConverter struct{}
diff --git a/src/database/sql/fakedb_test.go b/src/database/sql/fakedb_test.go
index f1e8f6c..b5ff1213 100644
--- a/src/database/sql/fakedb_test.go
+++ b/src/database/sql/fakedb_test.go
@@ -33,6 +33,9 @@
// INSERT|<tablename>|col=val,col2=val2,col3=?
// SELECT|<tablename>|projectcol1,projectcol2|filtercol=?,filtercol2=?
//
+// Any of these can be preceded by PANIC|<method>|, to cause the
+// named method on fakeStmt to panic.
+//
// When opening a fakeDriver's database, it starts empty with no
// tables. All tables and data are stored in memory only.
type fakeDriver struct {
@@ -111,6 +114,7 @@
cmd string
table string
+ panic string
closed bool
@@ -499,9 +503,15 @@
if len(parts) < 1 {
return nil, errf("empty query")
}
+ stmt := &fakeStmt{q: query, c: c}
+ if len(parts) >= 3 && parts[0] == "PANIC" {
+ stmt.panic = parts[1]
+ parts = parts[2:]
+ }
cmd := parts[0]
+ stmt.cmd = cmd
parts = parts[1:]
- stmt := &fakeStmt{q: query, c: c, cmd: cmd}
+
c.incrStat(&c.stmtsMade)
switch cmd {
case "WIPE":
@@ -524,6 +534,9 @@
}
func (s *fakeStmt) ColumnConverter(idx int) driver.ValueConverter {
+ if s.panic == "ColumnConverter" {
+ panic(s.panic)
+ }
if len(s.placeholderConverter) == 0 {
return driver.DefaultParameterConverter
}
@@ -531,6 +544,9 @@
}
func (s *fakeStmt) Close() error {
+ if s.panic == "Close" {
+ panic(s.panic)
+ }
if s.c == nil {
panic("nil conn in fakeStmt.Close")
}
@@ -550,6 +566,9 @@
var hookExecBadConn func() bool
func (s *fakeStmt) Exec(args []driver.Value) (driver.Result, error) {
+ if s.panic == "Exec" {
+ panic(s.panic)
+ }
if s.closed {
return nil, errClosed
}
@@ -634,6 +653,9 @@
var hookQueryBadConn func() bool
func (s *fakeStmt) Query(args []driver.Value) (driver.Rows, error) {
+ if s.panic == "Query" {
+ panic(s.panic)
+ }
if s.closed {
return nil, errClosed
}
@@ -716,6 +738,9 @@
}
func (s *fakeStmt) NumInput() int {
+ if s.panic == "NumInput" {
+ panic(s.panic)
+ }
return s.placeholders
}
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 2d1528a..b5a17f0 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -1477,10 +1477,14 @@
return nil, driver.ErrBadConn
}
-func resultFromStatement(ds driverStmt, args ...interface{}) (Result, error) {
+func driverNumInput(ds driverStmt) int {
ds.Lock()
- want := ds.si.NumInput()
- ds.Unlock()
+ defer ds.Unlock() // in case NumInput panics
+ return ds.si.NumInput()
+}
+
+func resultFromStatement(ds driverStmt, args ...interface{}) (Result, error) {
+ want := driverNumInput(ds)
// -1 means the driver doesn't know how to count the number of
// placeholders, so we won't sanity check input here and instead let the
@@ -1495,8 +1499,8 @@
}
ds.Lock()
+ defer ds.Unlock()
resi, err := ds.si.Exec(dargs)
- ds.Unlock()
if err != nil {
return nil, err
}
@@ -1927,6 +1931,6 @@
// withLock runs while holding lk.
func withLock(lk sync.Locker, fn func()) {
lk.Lock()
+ defer lk.Unlock() // in case fn panics
fn()
- lk.Unlock()
}
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 48c872d..8ec70d9 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -68,6 +68,46 @@
return db
}
+func TestDriverPanic(t *testing.T) {
+ // Test that if driver panics, database/sql does not deadlock.
+ db, err := Open("test", fakeDBName)
+ if err != nil {
+ t.Fatalf("Open: %v", err)
+ }
+ expectPanic := func(name string, f func()) {
+ defer func() {
+ err := recover()
+ if err == nil {
+ t.Fatalf("%s did not panic", name)
+ }
+ }()
+ f()
+ }
+
+ expectPanic("Exec Exec", func() { db.Exec("PANIC|Exec|WIPE") })
+ exec(t, db, "WIPE") // check not deadlocked
+ expectPanic("Exec NumInput", func() { db.Exec("PANIC|NumInput|WIPE") })
+ exec(t, db, "WIPE") // check not deadlocked
+ expectPanic("Exec Close", func() { db.Exec("PANIC|Close|WIPE") })
+ exec(t, db, "WIPE") // check not deadlocked
+ exec(t, db, "PANIC|Query|WIPE") // should run successfully: Exec does not call Query
+ exec(t, db, "WIPE") // check not deadlocked
+
+ exec(t, db, "CREATE|people|name=string,age=int32,photo=blob,dead=bool,bdate=datetime")
+
+ expectPanic("Query Query", func() { db.Query("PANIC|Query|SELECT|people|age,name|") })
+ expectPanic("Query NumInput", func() { db.Query("PANIC|NumInput|SELECT|people|age,name|") })
+ expectPanic("Query Close", func() {
+ rows, err := db.Query("PANIC|Close|SELECT|people|age,name|")
+ if err != nil {
+ t.Fatal(err)
+ }
+ rows.Close()
+ })
+ db.Query("PANIC|Exec|SELECT|people|age,name|") // should run successfully: Query does not call Exec
+ exec(t, db, "WIPE") // check not deadlocked
+}
+
func exec(t testing.TB, db *DB, query string, args ...interface{}) {
_, err := db.Exec(query, args...)
if err != nil {
diff --git a/src/debug/dwarf/testdata/cycle.c b/src/debug/dwarf/testdata/cycle.c
new file mode 100644
index 0000000..a0b53df
--- /dev/null
+++ b/src/debug/dwarf/testdata/cycle.c
@@ -0,0 +1,7 @@
+typedef struct aaa *AAA;
+typedef AAA BBB;
+struct aaa { BBB val; };
+
+AAA x(void) {
+ return (AAA)0;
+}
diff --git a/src/debug/dwarf/testdata/cycle.elf b/src/debug/dwarf/testdata/cycle.elf
new file mode 100644
index 0000000..e0b66ca
--- /dev/null
+++ b/src/debug/dwarf/testdata/cycle.elf
Binary files differ
diff --git a/src/debug/dwarf/type.go b/src/debug/dwarf/type.go
index a5daa1d..c76a472 100644
--- a/src/debug/dwarf/type.go
+++ b/src/debug/dwarf/type.go
@@ -275,12 +275,14 @@
// Type reads the type at off in the DWARF ``info'' section.
func (d *Data) Type(off Offset) (Type, error) {
- return d.readType("info", d.Reader(), off, d.typeCache)
+ return d.readType("info", d.Reader(), off, d.typeCache, nil)
}
-// readType reads a type from r at off of name using and updating a
-// type cache.
-func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type) (Type, error) {
+// readType reads a type from r at off of name. It adds types to the
+// type cache, appends new typedef types to typedefs, and computes the
+// sizes of types. Callers should pass nil for typedefs; this is used
+// for internal recursion.
+func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, typedefs *[]*TypedefType) (Type, error) {
if t, ok := typeCache[off]; ok {
return t, nil
}
@@ -294,9 +296,24 @@
return nil, DecodeError{name, off, "no type at offset"}
}
+ // If this is the root of the recursion, prepare to resolve
+ // typedef sizes once the recursion is done. This must be done
+ // after the type graph is constructed because it may need to
+ // resolve cycles in a different order than readType
+ // encounters them.
+ if typedefs == nil {
+ var typedefList []*TypedefType
+ defer func() {
+ for _, t := range typedefList {
+ t.Common().ByteSize = t.Type.Size()
+ }
+ }()
+ typedefs = &typedefList
+ }
+
// Parse type from Entry.
// Must always set typeCache[off] before calling
- // d.Type recursively, to handle circular types correctly.
+ // d.readType recursively, to handle circular types correctly.
var typ Type
nextDepth := 0
@@ -345,7 +362,7 @@
var t Type
switch toff := tval.(type) {
case Offset:
- if t, err = d.readType(name, r.clone(), toff, typeCache); err != nil {
+ if t, err = d.readType(name, r.clone(), toff, typeCache, typedefs); err != nil {
return nil
}
case uint64:
@@ -674,7 +691,10 @@
b = -1
switch t := typ.(type) {
case *TypedefType:
- b = t.Type.Size()
+ // Record that we need to resolve this
+ // type's size once the type graph is
+ // constructed.
+ *typedefs = append(*typedefs, t)
case *PtrType:
b = int64(addressSize)
}
diff --git a/src/debug/dwarf/type_test.go b/src/debug/dwarf/type_test.go
index 2cb85e7..ad6308d 100644
--- a/src/debug/dwarf/type_test.go
+++ b/src/debug/dwarf/type_test.go
@@ -120,3 +120,37 @@
}
}
}
+
+func TestTypedefCycle(t *testing.T) {
+ // See issue #13039: reading a typedef cycle starting from a
+ // different place than the size needed to be computed from
+ // used to crash.
+ //
+ // cycle.elf built with GCC 4.8.4:
+ // gcc -g -c -o cycle.elf cycle.c
+ d := elfData(t, "testdata/cycle.elf")
+ r := d.Reader()
+ offsets := []Offset{}
+ for {
+ e, err := r.Next()
+ if err != nil {
+ t.Fatal("r.Next:", err)
+ }
+ if e == nil {
+ break
+ }
+ switch e.Tag {
+ case TagBaseType, TagTypedef, TagPointerType, TagStructType:
+ offsets = append(offsets, e.Offset)
+ }
+ }
+
+ // Parse each type with a fresh type cache.
+ for _, offset := range offsets {
+ d := elfData(t, "testdata/cycle.elf")
+ _, err := d.Type(offset)
+ if err != nil {
+ t.Fatalf("d.Type(0x%x): %s", offset, err)
+ }
+ }
+}
diff --git a/src/debug/dwarf/typeunit.go b/src/debug/dwarf/typeunit.go
index 9cfb4a8..0f4e07e 100644
--- a/src/debug/dwarf/typeunit.go
+++ b/src/debug/dwarf/typeunit.go
@@ -101,7 +101,7 @@
b := makeBuf(d, tu, tu.name, tu.off, tu.data)
r := &typeUnitReader{d: d, tu: tu, b: b}
- t, err := d.readType(tu.name, r, Offset(tu.toff), make(map[Offset]Type))
+ t, err := d.readType(tu.name, r, Offset(tu.toff), make(map[Offset]Type), nil)
if err != nil {
return nil, err
}
diff --git a/src/encoding/base64/base64.go b/src/encoding/base64/base64.go
index 4f665d3..1bda804 100644
--- a/src/encoding/base64/base64.go
+++ b/src/encoding/base64/base64.go
@@ -346,21 +346,18 @@
}
type decoder struct {
- err error
- enc *Encoding
- r io.Reader
- end bool // saw end of message
- buf [1024]byte // leftover input
- nbuf int
- out []byte // leftover decoded output
- outbuf [1024 / 4 * 3]byte
+ err error
+ readErr error // error from r.Read
+ enc *Encoding
+ r io.Reader
+ end bool // saw end of message
+ buf [1024]byte // leftover input
+ nbuf int
+ out []byte // leftover decoded output
+ outbuf [1024 / 4 * 3]byte
}
func (d *decoder) Read(p []byte) (n int, err error) {
- if d.err != nil {
- return 0, d.err
- }
-
// Use leftover decoded output from last read.
if len(d.out) > 0 {
n = copy(p, d.out)
@@ -368,19 +365,46 @@
return n, nil
}
+ if d.err != nil {
+ return 0, d.err
+ }
+
// This code assumes that d.r strips supported whitespace ('\r' and '\n').
- // Read a chunk.
- nn := len(p) / 3 * 4
- if nn < 4 {
- nn = 4
+ // Refill buffer.
+ for d.nbuf < 4 && d.readErr == nil {
+ nn := len(p) / 3 * 4
+ if nn < 4 {
+ nn = 4
+ }
+ if nn > len(d.buf) {
+ nn = len(d.buf)
+ }
+ nn, d.readErr = d.r.Read(d.buf[d.nbuf:nn])
+ d.nbuf += nn
}
- if nn > len(d.buf) {
- nn = len(d.buf)
- }
- nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf)
- d.nbuf += nn
- if d.err != nil || d.nbuf < 4 {
+
+ if d.nbuf < 4 {
+ if d.enc.padChar == NoPadding && d.nbuf > 0 {
+ // Decode final fragment, without padding.
+ var nw int
+ nw, _, d.err = d.enc.decode(d.outbuf[:], d.buf[:d.nbuf])
+ d.nbuf = 0
+ d.end = true
+ d.out = d.outbuf[:nw]
+ n = copy(p, d.out)
+ d.out = d.out[n:]
+ if n > 0 || len(p) == 0 && len(d.out) > 0 {
+ return n, nil
+ }
+ if d.err != nil {
+ return 0, d.err
+ }
+ }
+ d.err = d.readErr
+ if d.err == io.EOF && d.nbuf > 0 {
+ d.err = io.ErrUnexpectedEOF
+ }
return 0, d.err
}
@@ -396,13 +420,7 @@
n, d.end, d.err = d.enc.decode(p, d.buf[:nr])
}
d.nbuf -= nr
- for i := 0; i < d.nbuf; i++ {
- d.buf[i] = d.buf[i+nr]
- }
-
- if d.err == nil {
- d.err = err
- }
+ copy(d.buf[:d.nbuf], d.buf[nr:])
return n, d.err
}
diff --git a/src/encoding/base64/base64_test.go b/src/encoding/base64/base64_test.go
index 4bbb2dd..fc6a1ea 100644
--- a/src/encoding/base64/base64_test.go
+++ b/src/encoding/base64/base64_test.go
@@ -406,3 +406,28 @@
StdEncoding.DecodeString(data)
}
}
+
+func TestDecoderRaw(t *testing.T) {
+ source := "AAAAAA"
+ want := []byte{0, 0, 0, 0}
+
+ // Direct.
+ dec1, err := RawURLEncoding.DecodeString(source)
+ if err != nil || !bytes.Equal(dec1, want) {
+ t.Errorf("RawURLEncoding.DecodeString(%q) = %x, %v, want %x, nil", source, dec1, err, want)
+ }
+
+ // Through reader. Used to fail.
+ r := NewDecoder(RawURLEncoding, bytes.NewReader([]byte(source)))
+ dec2, err := ioutil.ReadAll(io.LimitReader(r, 100))
+ if err != nil || !bytes.Equal(dec2, want) {
+ t.Errorf("reading NewDecoder(RawURLEncoding, %q) = %x, %v, want %x, nil", source, dec2, err, want)
+ }
+
+ // Should work with padding.
+ r = NewDecoder(URLEncoding, bytes.NewReader([]byte(source+"==")))
+ dec3, err := ioutil.ReadAll(r)
+ if err != nil || !bytes.Equal(dec3, want) {
+ t.Errorf("reading NewDecoder(URLEncoding, %q) = %x, %v, want %x, nil", source+"==", dec3, err, want)
+ }
+}
diff --git a/src/encoding/json/decode.go b/src/encoding/json/decode.go
index 099d7f6..539d952a 100644
--- a/src/encoding/json/decode.go
+++ b/src/encoding/json/decode.go
@@ -37,6 +37,7 @@
// To unmarshal JSON into a struct, Unmarshal matches incoming object
// keys to the keys used by Marshal (either the struct field name or its tag),
// preferring an exact match but also accepting a case-insensitive match.
+// Unmarshal will only set exported fields of the struct.
//
// To unmarshal JSON into an interface value,
// Unmarshal stores one of these in the interface value:
diff --git a/src/go/build/build.go b/src/go/build/build.go
index c942670..c1b70bc 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -344,18 +344,20 @@
// See golang.org/s/go14customimport for more information.
ImportComment
- // If AllowVendor is set, Import searches vendor directories
+ // By default, Import searches vendor directories
// that apply in the given source directory before searching
// the GOROOT and GOPATH roots.
// If an Import finds and returns a package using a vendor
// directory, the resulting ImportPath is the complete path
// to the package, including the path elements leading up
// to and including "vendor".
- // For example, if Import("y", "x/subdir", AllowVendor) finds
+ // For example, if Import("y", "x/subdir", 0) finds
// "x/vendor/y", the returned package's ImportPath is "x/vendor/y",
// not plain "y".
// See golang.org/s/go15vendor for more information.
- AllowVendor
+ //
+ // Setting IgnoreVendor ignores vendor directories.
+ IgnoreVendor
)
// A Package describes the Go package found in a directory.
@@ -571,7 +573,7 @@
gopath := ctxt.gopath()
// Vendor directories get first chance to satisfy import.
- if mode&AllowVendor != 0 && srcDir != "" {
+ if mode&IgnoreVendor == 0 && srcDir != "" {
searchVendor := func(root string, isGoroot bool) bool {
sub, ok := ctxt.hasSubdir(root, srcDir)
if !ok || !strings.HasPrefix(sub, "src/") || strings.Contains(sub, "/testdata/") {
@@ -581,7 +583,7 @@
vendor := ctxt.joinPath(root, sub, "vendor")
if ctxt.isDir(vendor) {
dir := ctxt.joinPath(vendor, path)
- if ctxt.isDir(dir) {
+ if ctxt.isDir(dir) && hasGoFiles(ctxt, dir) {
p.Dir = dir
p.ImportPath = strings.TrimPrefix(pathpkg.Join(sub, "vendor", path), "src/")
p.Goroot = isGoroot
@@ -882,6 +884,20 @@
return p, pkgerr
}
+// hasGoFiles reports whether dir contains any files with names ending in .go.
+// For a vendor check we must exclude directories that contain no .go files.
+// Otherwise it is not possible to vendor just a/b/c and still import the
+// non-vendored a/b. See golang.org/issue/13832.
+func hasGoFiles(ctxt *Context, dir string) bool {
+ ents, _ := ctxt.readDir(dir)
+ for _, ent := range ents {
+ if !ent.IsDir() && strings.HasSuffix(ent.Name(), ".go") {
+ return true
+ }
+ }
+ return false
+}
+
func findImportComment(data []byte) (s string, line int) {
// expect keyword package
word, data := parseWord(data)
diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 07efc14..61aac8f 100644
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -303,7 +303,7 @@
testenv.MustHaveGoBuild(t) // really must just have source
ctxt := Default
ctxt.GOPATH = ""
- p, err := ctxt.Import("golang.org/x/net/http2/hpack", filepath.Join(ctxt.GOROOT, "src/net/http"), AllowVendor)
+ p, err := ctxt.Import("golang.org/x/net/http2/hpack", filepath.Join(ctxt.GOROOT, "src/net/http"), 0)
if err != nil {
t.Fatalf("cannot find vendored golang.org/x/net/http2/hpack from net/http directory: %v", err)
}
@@ -317,7 +317,7 @@
testenv.MustHaveGoBuild(t) // really must just have source
ctxt := Default
ctxt.GOPATH = ""
- p, err := ctxt.Import("x.com/y/z", filepath.Join(ctxt.GOROOT, "src/net/http"), AllowVendor)
+ p, err := ctxt.Import("x.com/y/z", filepath.Join(ctxt.GOROOT, "src/net/http"), 0)
if err == nil {
t.Fatalf("found made-up package x.com/y/z in %s", p.Dir)
}
@@ -327,3 +327,21 @@
t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e)
}
}
+
+func TestImportVendorParentFailure(t *testing.T) {
+ testenv.MustHaveGoBuild(t) // really must just have source
+ ctxt := Default
+ ctxt.GOPATH = ""
+ // This import should fail because the vendor/golang.org/x/net/http2 directory has no source code.
+ p, err := ctxt.Import("golang.org/x/net/http2", filepath.Join(ctxt.GOROOT, "src/net/http"), 0)
+ if err == nil {
+ t.Fatalf("found empty parent in %s", p.Dir)
+ }
+ if p != nil && p.Dir != "" {
+ t.Fatalf("decided to use %s", p.Dir)
+ }
+ e := err.Error()
+ if !strings.Contains(e, " (vendor tree)") {
+ t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e)
+ }
+}
diff --git a/src/go/doc/reader.go b/src/go/doc/reader.go
index f5c02b6..e4e7b7c 100644
--- a/src/go/doc/reader.go
+++ b/src/go/doc/reader.go
@@ -151,10 +151,11 @@
notes map[string][]*Note
// declarations
- imports map[string]int
- values []*Value // consts and vars
- types map[string]*namedType
- funcs methodSet
+ imports map[string]int
+ hasDotImp bool // if set, package contains a dot import
+ values []*Value // consts and vars
+ types map[string]*namedType
+ funcs methodSet
// support for package-local error type declarations
errorDecl bool // if set, type "error" was declared locally
@@ -471,6 +472,9 @@
if s, ok := spec.(*ast.ImportSpec); ok {
if import_, err := strconv.Unquote(s.Path.Value); err == nil {
r.imports[import_] = 1
+ if s.Name != nil && s.Name.Name == "." {
+ r.hasDotImp = true
+ }
}
}
}
@@ -641,11 +645,12 @@
func (r *reader) cleanupTypes() {
for _, t := range r.types {
visible := r.isVisible(t.name)
- if t.decl == nil && (predeclaredTypes[t.name] || t.isEmbedded && visible) {
+ if t.decl == nil && (predeclaredTypes[t.name] || visible && (t.isEmbedded || r.hasDotImp)) {
// t.name is a predeclared type (and was not redeclared in this package),
// or it was embedded somewhere but its declaration is missing (because
- // the AST is incomplete): move any associated values, funcs, and methods
- // back to the top-level so that they are not lost.
+ // the AST is incomplete), or we have a dot-import (and all bets are off):
+ // move any associated values, funcs, and methods back to the top-level so
+ // that they are not lost.
// 1) move values
r.values = append(r.values, t.values...)
// 2) move factory functions
diff --git a/src/go/doc/testdata/issue13742.0.golden b/src/go/doc/testdata/issue13742.0.golden
new file mode 100644
index 0000000..8dee9aa
--- /dev/null
+++ b/src/go/doc/testdata/issue13742.0.golden
@@ -0,0 +1,25 @@
+//
+PACKAGE issue13742
+
+IMPORTPATH
+ testdata/issue13742
+
+IMPORTS
+ go/ast
+
+FILENAMES
+ testdata/issue13742.go
+
+FUNCTIONS
+ // Both F0 and G0 should appear as functions.
+ func F0(Node)
+
+ // Both F1 and G1 should appear as functions.
+ func F1(ast.Node)
+
+ //
+ func G0() Node
+
+ //
+ func G1() ast.Node
+
diff --git a/src/go/doc/testdata/issue13742.1.golden b/src/go/doc/testdata/issue13742.1.golden
new file mode 100644
index 0000000..8dee9aa
--- /dev/null
+++ b/src/go/doc/testdata/issue13742.1.golden
@@ -0,0 +1,25 @@
+//
+PACKAGE issue13742
+
+IMPORTPATH
+ testdata/issue13742
+
+IMPORTS
+ go/ast
+
+FILENAMES
+ testdata/issue13742.go
+
+FUNCTIONS
+ // Both F0 and G0 should appear as functions.
+ func F0(Node)
+
+ // Both F1 and G1 should appear as functions.
+ func F1(ast.Node)
+
+ //
+ func G0() Node
+
+ //
+ func G1() ast.Node
+
diff --git a/src/go/doc/testdata/issue13742.2.golden b/src/go/doc/testdata/issue13742.2.golden
new file mode 100644
index 0000000..8dee9aa
--- /dev/null
+++ b/src/go/doc/testdata/issue13742.2.golden
@@ -0,0 +1,25 @@
+//
+PACKAGE issue13742
+
+IMPORTPATH
+ testdata/issue13742
+
+IMPORTS
+ go/ast
+
+FILENAMES
+ testdata/issue13742.go
+
+FUNCTIONS
+ // Both F0 and G0 should appear as functions.
+ func F0(Node)
+
+ // Both F1 and G1 should appear as functions.
+ func F1(ast.Node)
+
+ //
+ func G0() Node
+
+ //
+ func G1() ast.Node
+
diff --git a/src/go/doc/testdata/issue13742.go b/src/go/doc/testdata/issue13742.go
new file mode 100644
index 0000000..dbc1941
--- /dev/null
+++ b/src/go/doc/testdata/issue13742.go
@@ -0,0 +1,18 @@
+// Copyright 2016 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 issue13742
+
+import (
+ "go/ast"
+ . "go/ast"
+)
+
+// Both F0 and G0 should appear as functions.
+func F0(Node) {}
+func G0() Node { return nil }
+
+// Both F1 and G1 should appear as functions.
+func F1(ast.Node) {}
+func G1() ast.Node { return nil }
diff --git a/src/go/importer/importer.go b/src/go/importer/importer.go
index 4590ca3..560b853 100644
--- a/src/go/importer/importer.go
+++ b/src/go/importer/importer.go
@@ -20,31 +20,37 @@
// For returns an Importer for the given compiler and lookup interface,
// or nil. Supported compilers are "gc", and "gccgo". If lookup is nil,
// the default package lookup mechanism for the given compiler is used.
+// BUG(issue13847): For does not support non-nil lookup functions.
func For(compiler string, lookup Lookup) types.Importer {
switch compiler {
case "gc":
- if lookup == nil {
- return make(gcimports)
+ if lookup != nil {
+ panic("gc importer for custom import path lookup not yet implemented")
}
- panic("gc importer for custom import path lookup not yet implemented")
+
+ return make(gcimports)
+
case "gccgo":
if lookup == nil {
- var inst gccgoimporter.GccgoInstallation
- if err := inst.InitFromDriver("gccgo"); err != nil {
- return nil
- }
- return &gccgoimports{
- packages: make(map[string]*types.Package),
- importer: inst.GetImporter(nil, nil),
- }
+ panic("gccgo importer for custom import path lookup not yet implemented")
}
- panic("gccgo importer for custom import path lookup not yet implemented")
+
+ var inst gccgoimporter.GccgoInstallation
+ if err := inst.InitFromDriver("gccgo"); err != nil {
+ return nil
+ }
+ return &gccgoimports{
+ packages: make(map[string]*types.Package),
+ importer: inst.GetImporter(nil, nil),
+ }
}
+
// compiler not supported
return nil
}
// Default returns an Importer for the compiler that built the running binary.
+// If available, the result implements types.ImporterFrom.
func Default() types.Importer {
return For(runtime.Compiler, nil)
}
@@ -54,7 +60,14 @@
type gcimports map[string]*types.Package
func (m gcimports) Import(path string) (*types.Package, error) {
- return gcimporter.Import(m, path)
+ return m.ImportFrom(path, "" /* no vendoring */, 0)
+}
+
+func (m gcimports) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) {
+ if mode != 0 {
+ panic("mode must be 0")
+ }
+ return gcimporter.Import(m, path, srcDir)
}
// gccgo support
@@ -65,5 +78,13 @@
}
func (m *gccgoimports) Import(path string) (*types.Package, error) {
+ return m.ImportFrom(path, "" /* no vendoring */, 0)
+}
+
+func (m *gccgoimports) ImportFrom(path, srcDir string, mode types.ImportMode) (*types.Package, error) {
+ if mode != 0 {
+ panic("mode must be 0")
+ }
+ // TODO(gri) pass srcDir
return m.importer(m.packages, path)
}
diff --git a/src/go/internal/gcimporter/bimport.go b/src/go/internal/gcimporter/bimport.go
index ce36218..6869042 100644
--- a/src/go/internal/gcimporter/bimport.go
+++ b/src/go/internal/gcimporter/bimport.go
@@ -72,7 +72,7 @@
// read consts
for i := p.int(); i > 0; i-- {
name := p.string()
- typ := p.typ()
+ typ := p.typ(nil)
val := p.value()
p.declare(types.NewConst(token.NoPos, pkg, name, typ, val))
}
@@ -80,14 +80,14 @@
// read vars
for i := p.int(); i > 0; i-- {
name := p.string()
- typ := p.typ()
+ typ := p.typ(nil)
p.declare(types.NewVar(token.NoPos, pkg, name, typ))
}
// read funcs
for i := p.int(); i > 0; i-- {
name := p.string()
- sig := p.typ().(*types.Signature)
+ sig := p.typ(nil).(*types.Signature)
p.int() // read and discard index of inlined function body
p.declare(types.NewFunc(token.NoPos, pkg, name, sig))
}
@@ -97,7 +97,7 @@
// name is parsed as part of named type and the
// type object is added to scope via respective
// named type
- _ = p.typ().(*types.Named)
+ _ = p.typ(nil).(*types.Named)
}
// ignore compiler-specific import data
@@ -190,7 +190,11 @@
func (t *dddSlice) Underlying() types.Type { return t }
func (t *dddSlice) String() string { return "..." + t.elem.String() }
-func (p *importer) typ() types.Type {
+// parent is the package which declared the type; parent == nil means
+// the package currently imported. The parent package is needed for
+// exported struct fields and interface methods which don't contain
+// explicit package information in the export data.
+func (p *importer) typ(parent *types.Package) types.Type {
// if the type was seen before, i is its index (>= 0)
i := p.tagOrIndex()
if i >= 0 {
@@ -202,18 +206,18 @@
case namedTag:
// read type object
name := p.string()
- tpkg := p.pkg()
- scope := tpkg.Scope()
+ parent = p.pkg()
+ scope := parent.Scope()
obj := scope.Lookup(name)
// if the object doesn't exist yet, create and insert it
if obj == nil {
- obj = types.NewTypeName(token.NoPos, tpkg, name, nil)
+ obj = types.NewTypeName(token.NoPos, parent, name, nil)
scope.Insert(obj)
}
if _, ok := obj.(*types.TypeName); !ok {
- panic(fmt.Sprintf("pkg = %s, name = %s => %s", tpkg, name, obj))
+ panic(fmt.Sprintf("pkg = %s, name = %s => %s", parent, name, obj))
}
// associate new named type with obj if it doesn't exist yet
@@ -224,7 +228,7 @@
p.record(t)
// read underlying type
- t0.SetUnderlying(p.typ())
+ t0.SetUnderlying(p.typ(parent))
// interfaces don't have associated methods
if _, ok := t0.Underlying().(*types.Interface); ok {
@@ -239,7 +243,7 @@
result, _ := p.paramList()
p.int() // read and discard index of inlined function body
sig := types.NewSignature(recv.At(0), params, result, isddd)
- t0.AddMethod(types.NewFunc(token.NoPos, tpkg, name, sig))
+ t0.AddMethod(types.NewFunc(token.NoPos, parent, name, sig))
}
return t
@@ -249,21 +253,21 @@
p.record(t)
n := p.int64()
- *t = *types.NewArray(p.typ(), n)
+ *t = *types.NewArray(p.typ(parent), n)
return t
case sliceTag:
t := new(types.Slice)
p.record(t)
- *t = *types.NewSlice(p.typ())
+ *t = *types.NewSlice(p.typ(parent))
return t
case dddTag:
t := new(dddSlice)
p.record(t)
- t.elem = p.typ()
+ t.elem = p.typ(parent)
return t
case structTag:
@@ -274,7 +278,7 @@
fields := make([]*types.Var, n)
tags := make([]string, n)
for i := range fields {
- fields[i] = p.field()
+ fields[i] = p.field(parent)
tags[i] = p.string()
}
*t = *types.NewStruct(fields, tags)
@@ -284,7 +288,7 @@
t := new(types.Pointer)
p.record(t)
- *t = *types.NewPointer(p.typ())
+ *t = *types.NewPointer(p.typ(parent))
return t
case signatureTag:
@@ -312,7 +316,7 @@
// read methods
methods := make([]*types.Func, p.int())
for i := range methods {
- pkg, name := p.fieldName()
+ pkg, name := p.fieldName(parent)
params, isddd := p.paramList()
result, _ := p.paramList()
sig := types.NewSignature(nil, params, result, isddd)
@@ -327,8 +331,8 @@
t := new(types.Map)
p.record(t)
- key := p.typ()
- val := p.typ()
+ key := p.typ(parent)
+ val := p.typ(parent)
*t = *types.NewMap(key, val)
return t
@@ -348,7 +352,7 @@
default:
panic(fmt.Sprintf("unexpected channel dir %d", d))
}
- val := p.typ()
+ val := p.typ(parent)
*t = *types.NewChan(dir, val)
return t
@@ -357,18 +361,18 @@
}
}
-func (p *importer) field() *types.Var {
- pkg, name := p.fieldName()
- typ := p.typ()
+func (p *importer) field(parent *types.Package) *types.Var {
+ pkg, name := p.fieldName(parent)
+ typ := p.typ(parent)
anonymous := false
if name == "" {
// anonymous field - typ must be T or *T and T must be a type name
switch typ := deref(typ).(type) {
case *types.Basic: // basic types are named types
+ pkg = nil // // objects defined in Universe scope have no package
name = typ.Name()
case *types.Named:
- pkg = p.pkgList[0]
name = typ.Obj().Name()
default:
panic("anonymous field expected")
@@ -379,15 +383,20 @@
return types.NewField(token.NoPos, pkg, name, typ, anonymous)
}
-func (p *importer) fieldName() (*types.Package, string) {
+func (p *importer) fieldName(parent *types.Package) (*types.Package, string) {
+ pkg := parent
+ if pkg == nil {
+ // use the imported package instead
+ pkg = p.pkgList[0]
+ }
name := p.string()
if name == "" {
- return nil, "" // anonymous field
+ return pkg, "" // anonymous
}
- pkg := p.pkgList[0]
if name == "?" || name != "_" && !exported(name) {
+ // explicitly qualified field
if name == "?" {
- name = ""
+ name = "" // anonymous
}
pkg = p.pkg()
}
@@ -415,7 +424,7 @@
}
func (p *importer) param(named bool) (*types.Var, bool) {
- t := p.typ()
+ t := p.typ(nil)
td, isddd := t.(*dddSlice)
if isddd {
t = types.NewSlice(td.elem)
diff --git a/src/go/internal/gcimporter/gcimporter.go b/src/go/internal/gcimporter/gcimporter.go
index 60dff32..0ef8eb4 100644
--- a/src/go/internal/gcimporter/gcimporter.go
+++ b/src/go/internal/gcimporter/gcimporter.go
@@ -35,11 +35,10 @@
// If no file was found, an empty filename is returned.
//
func FindPkg(path, srcDir string) (filename, id string) {
- if len(path) == 0 {
+ if path == "" {
return
}
- id = path
var noext string
switch {
default:
@@ -50,6 +49,7 @@
return
}
noext = strings.TrimSuffix(bp.PkgObj, ".a")
+ id = bp.ImportPath
case build.IsLocalImport(path):
// "./x" -> "/this/directory/x.ext", "/this/directory/x"
@@ -61,6 +61,13 @@
// does not support absolute imports
// "/x" -> "/x.ext", "/x"
noext = path
+ id = path
+ }
+
+ if false { // for debugging
+ if path != id {
+ fmt.Printf("%s -> %s\n", path, id)
+ }
}
// try extensions
@@ -107,27 +114,16 @@
return
}
-// Import imports a gc-generated package given its import path, adds the
-// corresponding package object to the packages map, and returns the object.
-// Local import paths are interpreted relative to the current working directory.
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
// The packages map must contain all packages already imported.
//
-func Import(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
- // package "unsafe" is handled by the type checker
- if path == "unsafe" {
- panic(`gcimporter.Import called for package "unsafe"`)
- }
-
- srcDir := "."
- if build.IsLocalImport(path) {
- srcDir, err = os.Getwd()
- if err != nil {
- return
- }
- }
-
+func Import(packages map[string]*types.Package, path, srcDir string) (pkg *types.Package, err error) {
filename, id := FindPkg(path, srcDir)
if filename == "" {
+ if path == "unsafe" {
+ return types.Unsafe, nil
+ }
err = fmt.Errorf("can't find import: %s", id)
return
}
@@ -417,11 +413,11 @@
// ArrayType = "[" int_lit "]" Type .
//
-func (p *parser) parseArrayType() types.Type {
+func (p *parser) parseArrayType(parent *types.Package) types.Type {
// "[" already consumed and lookahead known not to be "]"
lit := p.expect(scanner.Int)
p.expect(']')
- elem := p.parseType()
+ elem := p.parseType(parent)
n, err := strconv.ParseInt(lit, 10, 64)
if err != nil {
p.error(err)
@@ -431,35 +427,43 @@
// MapType = "map" "[" Type "]" Type .
//
-func (p *parser) parseMapType() types.Type {
+func (p *parser) parseMapType(parent *types.Package) types.Type {
p.expectKeyword("map")
p.expect('[')
- key := p.parseType()
+ key := p.parseType(parent)
p.expect(']')
- elem := p.parseType()
+ elem := p.parseType(parent)
return types.NewMap(key, elem)
}
// Name = identifier | "?" | QualifiedName .
//
-// For unqualified names, the returned package is the imported package.
+// For unqualified and anonymous names, the returned package is the parent
+// package unless parent == nil, in which case the returned package is the
+// package being imported. (The parent package is not nil if the the name
+// is an unqualified struct field or interface method name belonging to a
+// type declared in another package.)
+//
// For qualified names, the returned package is nil (and not created if
// it doesn't exist yet) unless materializePkg is set (which creates an
-// unnamed package). In the latter case, a subequent import clause is
-// expected to provide a name for the package.
+// unnamed package with valid package path). In the latter case, a
+// subequent import clause is expected to provide a name for the package.
//
-func (p *parser) parseName(materializePkg bool) (pkg *types.Package, name string) {
+func (p *parser) parseName(parent *types.Package, materializePkg bool) (pkg *types.Package, name string) {
+ pkg = parent
+ if pkg == nil {
+ pkg = p.sharedPkgs[p.id]
+ }
switch p.tok {
case scanner.Ident:
- pkg = p.sharedPkgs[p.id]
name = p.lit
p.next()
case '?':
// anonymous
- pkg = p.sharedPkgs[p.id]
p.next()
case '@':
// exported name prefixed with package path
+ pkg = nil
var id string
id, name = p.parseQualifiedName()
if materializePkg {
@@ -480,15 +484,15 @@
// Field = Name Type [ string_lit ] .
//
-func (p *parser) parseField() (*types.Var, string) {
- pkg, name := p.parseName(true)
- typ := p.parseType()
+func (p *parser) parseField(parent *types.Package) (*types.Var, string) {
+ pkg, name := p.parseName(parent, true)
+ typ := p.parseType(parent)
anonymous := false
if name == "" {
// anonymous field - typ must be T or *T and T must be a type name
switch typ := deref(typ).(type) {
case *types.Basic: // basic types are named types
- pkg = nil
+ pkg = nil // objects defined in Universe scope have no package
name = typ.Name()
case *types.Named:
name = typ.Obj().Name()
@@ -512,7 +516,7 @@
// StructType = "struct" "{" [ FieldList ] "}" .
// FieldList = Field { ";" Field } .
//
-func (p *parser) parseStructType() types.Type {
+func (p *parser) parseStructType(parent *types.Package) types.Type {
var fields []*types.Var
var tags []string
@@ -522,7 +526,7 @@
if i > 0 {
p.expect(';')
}
- fld, tag := p.parseField()
+ fld, tag := p.parseField(parent)
if tag != "" && tags == nil {
tags = make([]string, i)
}
@@ -539,7 +543,7 @@
// Parameter = ( identifier | "?" ) [ "..." ] Type [ string_lit ] .
//
func (p *parser) parseParameter() (par *types.Var, isVariadic bool) {
- _, name := p.parseName(false)
+ _, name := p.parseName(nil, false)
// remove gc-specific parameter numbering
if i := strings.Index(name, "·"); i >= 0 {
name = name[:i]
@@ -548,7 +552,7 @@
p.expectSpecial("...")
isVariadic = true
}
- typ := p.parseType()
+ typ := p.parseType(nil)
if isVariadic {
typ = types.NewSlice(typ)
}
@@ -611,7 +615,7 @@
// by the compiler and thus embedded interfaces are never
// visible in the export data.
//
-func (p *parser) parseInterfaceType() types.Type {
+func (p *parser) parseInterfaceType(parent *types.Package) types.Type {
var methods []*types.Func
p.expectKeyword("interface")
@@ -620,7 +624,7 @@
if i > 0 {
p.expect(';')
}
- pkg, name := p.parseName(true)
+ pkg, name := p.parseName(parent, true)
sig := p.parseSignature(nil)
methods = append(methods, types.NewFunc(token.NoPos, pkg, name, sig))
}
@@ -633,7 +637,7 @@
// ChanType = ( "chan" [ "<-" ] | "<-" "chan" ) Type .
//
-func (p *parser) parseChanType() types.Type {
+func (p *parser) parseChanType(parent *types.Package) types.Type {
dir := types.SendRecv
if p.tok == scanner.Ident {
p.expectKeyword("chan")
@@ -646,7 +650,7 @@
p.expectKeyword("chan")
dir = types.RecvOnly
}
- elem := p.parseType()
+ elem := p.parseType(parent)
return types.NewChan(dir, elem)
}
@@ -661,24 +665,24 @@
// PointerType = "*" Type .
// FuncType = "func" Signature .
//
-func (p *parser) parseType() types.Type {
+func (p *parser) parseType(parent *types.Package) types.Type {
switch p.tok {
case scanner.Ident:
switch p.lit {
default:
return p.parseBasicType()
case "struct":
- return p.parseStructType()
+ return p.parseStructType(parent)
case "func":
// FuncType
p.next()
return p.parseSignature(nil)
case "interface":
- return p.parseInterfaceType()
+ return p.parseInterfaceType(parent)
case "map":
- return p.parseMapType()
+ return p.parseMapType(parent)
case "chan":
- return p.parseChanType()
+ return p.parseChanType(parent)
}
case '@':
// TypeName
@@ -689,19 +693,19 @@
if p.tok == ']' {
// SliceType
p.next()
- return types.NewSlice(p.parseType())
+ return types.NewSlice(p.parseType(parent))
}
- return p.parseArrayType()
+ return p.parseArrayType(parent)
case '*':
// PointerType
p.next()
- return types.NewPointer(p.parseType())
+ return types.NewPointer(p.parseType(parent))
case '<':
- return p.parseChanType()
+ return p.parseChanType(parent)
case '(':
// "(" Type ")"
p.next()
- typ := p.parseType()
+ typ := p.parseType(parent)
p.expect(')')
return typ
}
@@ -783,7 +787,8 @@
var typ0 types.Type
if p.tok != '=' {
- typ0 = p.parseType()
+ // constant types are never structured - no need for parent type
+ typ0 = p.parseType(nil)
}
p.expect('=')
@@ -857,7 +862,7 @@
// structure, but throw it away if the object already has a type.
// This ensures that all imports refer to the same type object for
// a given type declaration.
- typ := p.parseType()
+ typ := p.parseType(pkg)
if name := obj.Type().(*types.Named); name.Underlying() == nil {
name.SetUnderlying(typ)
@@ -869,7 +874,7 @@
func (p *parser) parseVarDecl() {
p.expectKeyword("var")
pkg, name := p.parseExportedName()
- typ := p.parseType()
+ typ := p.parseType(pkg)
pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, name, typ))
}
@@ -905,7 +910,7 @@
base := deref(recv.Type()).(*types.Named)
// parse method name, signature, and possibly inlined body
- _, name := p.parseName(false)
+ _, name := p.parseName(nil, false)
sig := p.parseFunc(recv)
// methods always belong to the same package as the base type object
diff --git a/src/go/internal/gcimporter/gcimporter_test.go b/src/go/internal/gcimporter/gcimporter_test.go
index a0ea60e..e56720b 100644
--- a/src/go/internal/gcimporter/gcimporter_test.go
+++ b/src/go/internal/gcimporter/gcimporter_test.go
@@ -60,9 +60,9 @@
return filepath.Join(dirname, filename[:len(filename)-2]+"o")
}
-func testPath(t *testing.T, path string) *types.Package {
+func testPath(t *testing.T, path, srcDir string) *types.Package {
t0 := time.Now()
- pkg, err := Import(make(map[string]*types.Package), path)
+ pkg, err := Import(make(map[string]*types.Package), path, srcDir)
if err != nil {
t.Errorf("testPath(%s): %s", path, err)
return nil
@@ -90,7 +90,7 @@
for _, ext := range pkgExts {
if strings.HasSuffix(f.Name(), ext) {
name := f.Name()[0 : len(f.Name())-len(ext)] // remove extension
- if testPath(t, filepath.Join(dir, name)) != nil {
+ if testPath(t, filepath.Join(dir, name), dir) != nil {
nimports++
}
}
@@ -113,7 +113,7 @@
defer os.Remove(outFn)
}
- if pkg := testPath(t, "./testdata/exports"); pkg != nil {
+ if pkg := testPath(t, "./testdata/exports", "."); pkg != nil {
// The package's Imports list must include all packages
// explicitly imported by exports.go, plus all packages
// referenced indirectly via exported objects in exports.go.
@@ -143,7 +143,7 @@
defer os.Remove(outFn)
}
- if pkg := testPath(t, "./testdata/exports"); pkg != nil {
+ if pkg := testPath(t, "./testdata/exports", "."); pkg != nil {
// The package's Imports list must include all packages
// explicitly imported by exports.go, plus all packages
// referenced indirectly via exported objects in exports.go.
@@ -200,7 +200,7 @@
importPath := s[0]
objName := s[1]
- pkg, err := Import(make(map[string]*types.Package), importPath)
+ pkg, err := Import(make(map[string]*types.Package), importPath, ".")
if err != nil {
t.Error(err)
continue
@@ -228,7 +228,7 @@
return
}
- pkg, err := Import(make(map[string]*types.Package), "strings")
+ pkg, err := Import(make(map[string]*types.Package), "strings", ".")
if err != nil {
t.Fatal(err)
}
@@ -262,7 +262,7 @@
}
imports := make(map[string]*types.Package)
- _, err := Import(imports, "net/http")
+ _, err := Import(imports, "net/http", ".")
if err != nil {
t.Fatal(err)
}
@@ -299,7 +299,7 @@
}
// import must succeed (test for issue at hand)
- pkg, err := Import(make(map[string]*types.Package), "./testdata/b")
+ pkg, err := Import(make(map[string]*types.Package), "./testdata/b", ".")
if err != nil {
t.Fatal(err)
}
@@ -311,3 +311,53 @@
}
}
}
+
+func TestIssue13898(t *testing.T) {
+ skipSpecialPlatforms(t)
+
+ // This package only handles gc export data.
+ if runtime.Compiler != "gc" {
+ t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
+ return
+ }
+
+ // import go/internal/gcimporter which imports go/types partially
+ imports := make(map[string]*types.Package)
+ _, err := Import(imports, "go/internal/gcimporter", ".")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // look for go/types package
+ var goTypesPkg *types.Package
+ for path, pkg := range imports {
+ if path == "go/types" {
+ goTypesPkg = pkg
+ break
+ }
+ }
+ if goTypesPkg == nil {
+ t.Fatal("go/types not found")
+ }
+
+ // look for go/types.Object type
+ obj := goTypesPkg.Scope().Lookup("Object")
+ if obj == nil {
+ t.Fatal("go/types.Object not found")
+ }
+ typ, ok := obj.Type().(*types.Named)
+ if !ok {
+ t.Fatalf("go/types.Object type is %v; wanted named type", typ)
+ }
+
+ // lookup go/types.Object.Pkg method
+ m, _, _ := types.LookupFieldOrMethod(typ, false, nil, "Pkg")
+ if m == nil {
+ t.Fatal("go/types.Object.Pkg not found")
+ }
+
+ // the method must belong to go/types
+ if m.Pkg().Path() != "go/types" {
+ t.Fatalf("found %v; want go/types", m.Pkg())
+ }
+}
diff --git a/src/go/types/api.go b/src/go/types/api.go
index 697c609..ca109f0 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -51,16 +51,42 @@
return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
}
-// An importer resolves import paths to Packages.
-// See go/importer for existing implementations.
+// An Importer resolves import paths to Packages.
+//
+// CAUTION: This interface does not support the import of locally
+// vendored packages. See https://golang.org/s/go15vendor.
+// If possible, external implementations should implement ImporterFrom.
type Importer interface {
// Import returns the imported package for the given import
// path, or an error if the package couldn't be imported.
- // Import is responsible for returning the same package for
- // matching import paths.
+ // Two calls to Import with the same path return the same
+ // package.
Import(path string) (*Package, error)
}
+// ImportMode is reserved for future use.
+type ImportMode int
+
+// An ImporterFrom resolves import paths to packages; it
+// supports vendoring per https://golang.org/s/go15vendor.
+// Use go/importer to obtain an ImporterFrom implementation.
+type ImporterFrom interface {
+ // Importer is present for backward-compatibility. Calling
+ // Import(path) is the same as calling ImportFrom(path, "", 0);
+ // i.e., locally vendored packages may not be found.
+ // The types package does not call Import if an ImporterFrom
+ // is present.
+ Importer
+
+ // ImportFrom returns the imported package for the given import
+ // path when imported by the package in srcDir, or an error
+ // if the package couldn't be imported. The mode value must
+ // be 0; it is reserved for future use.
+ // Two calls to ImportFrom with the same path and srcDir return
+ // the same package.
+ ImportFrom(path, srcDir string, mode ImportMode) (*Package, error)
+}
+
// A Config specifies the configuration for type checking.
// The zero value for Config is a ready-to-use default configuration.
type Config struct {
@@ -86,9 +112,12 @@
// error found.
Error func(err error)
- // Importer is called for each import declaration except when
- // importing package "unsafe". An error is reported if an
- // importer is needed but none was installed.
+ // An importer is used to import packages referred to from
+ // import declarations.
+ // If the installed importer implements ImporterFrom, the type
+ // checker calls ImportFrom instead of Import.
+ // The type checker reports an error if an importer is needed
+ // but none was installed.
Importer Importer
// If Sizes != nil, it provides the sizing functions for package unsafe.
diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go
index 672c78d..3884735 100644
--- a/src/go/types/issues_test.go
+++ b/src/go/types/issues_test.go
@@ -11,6 +11,7 @@
"go/ast"
"go/importer"
"go/parser"
+ "internal/testenv"
"sort"
"strings"
"testing"
@@ -204,3 +205,90 @@
t.Errorf("Unexpected defs/uses\ngot:\n%s\nwant:\n%s", got, want)
}
}
+
+// This tests that the package associated with the types.Object.Pkg method
+// is the type's package independent of the order in which the imports are
+// listed in the sources src1, src2 below.
+// The actual issue is in go/internal/gcimporter which has a corresponding
+// test; we leave this test here to verify correct behavior at the go/types
+// level.
+func TestIssue13898(t *testing.T) {
+ testenv.MustHaveGoBuild(t)
+
+ const src0 = `
+package main
+
+import "go/types"
+
+func main() {
+ var info types.Info
+ for _, obj := range info.Uses {
+ _ = obj.Pkg()
+ }
+}
+`
+ // like src0, but also imports go/importer
+ const src1 = `
+package main
+
+import (
+ "go/types"
+ _ "go/importer"
+)
+
+func main() {
+ var info types.Info
+ for _, obj := range info.Uses {
+ _ = obj.Pkg()
+ }
+}
+`
+ // like src1 but with different import order
+ // (used to fail with this issue)
+ const src2 = `
+package main
+
+import (
+ _ "go/importer"
+ "go/types"
+)
+
+func main() {
+ var info types.Info
+ for _, obj := range info.Uses {
+ _ = obj.Pkg()
+ }
+}
+`
+ f := func(test, src string) {
+ f, err := parser.ParseFile(fset, "", src, 0)
+ if err != nil {
+ t.Fatal(err)
+ }
+ cfg := Config{Importer: importer.Default()}
+ info := Info{Uses: make(map[*ast.Ident]Object)}
+ _, err = cfg.Check("main", fset, []*ast.File{f}, &info)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var pkg *Package
+ count := 0
+ for id, obj := range info.Uses {
+ if id.Name == "Pkg" {
+ pkg = obj.Pkg()
+ count++
+ }
+ }
+ if count != 1 {
+ t.Fatalf("%s: got %d entries named Pkg; want 1", test, count)
+ }
+ if pkg.Name() != "types" {
+ t.Fatalf("%s: got %v; want package types", test, pkg)
+ }
+ }
+
+ f("src0", src0)
+ f("src1", src1)
+ f("src2", src2)
+}
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index b52c3b2..14148a5 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -9,7 +9,6 @@
"go/ast"
"go/constant"
"go/token"
- pathLib "path"
"strconv"
"strings"
"unicode"
@@ -134,6 +133,20 @@
pkgImports[imp] = true
}
+ // srcDir is the directory used by the Importer to look up packages.
+ // The typechecker itself doesn't need this information so it is not
+ // explicitly provided. Instead, we extract it from position info of
+ // the source files as needed.
+ // This is the only place where the type-checker (just the importer)
+ // needs to know the actual source location of a file.
+ // TODO(gri) can we come up with a better API instead?
+ var srcDir string
+ if len(check.files) > 0 {
+ // FileName may be "" (typically for tests) in which case
+ // we get "." as the srcDir which is what we would want.
+ srcDir = dir(check.fset.Position(check.files[0].Name.Pos()).Filename)
+ }
+
for fileNo, file := range check.files {
// The package identifier denotes the current package,
// but there is no corresponding package object.
@@ -170,17 +183,20 @@
// TODO(gri) shouldn't create a new one each time
imp = NewPackage("C", "C")
imp.fake = true
- } else if path == "unsafe" {
- // package "unsafe" is known to the language
- imp = Unsafe
} else {
- if importer := check.conf.Importer; importer != nil {
+ // ordinary import
+ if importer := check.conf.Importer; importer == nil {
+ err = fmt.Errorf("Config.Importer not installed")
+ } else if importerFrom, ok := importer.(ImporterFrom); ok {
+ imp, err = importerFrom.ImportFrom(path, srcDir, 0)
+ if imp == nil && err == nil {
+ err = fmt.Errorf("Config.Importer.ImportFrom(%s, %s, 0) returned nil but no error", path, pkg.path)
+ }
+ } else {
imp, err = importer.Import(path)
if imp == nil && err == nil {
err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path)
}
- } else {
- err = fmt.Errorf("Config.Importer not installed")
}
if err != nil {
check.errorf(s.Path.Pos(), "could not import %s (%s)", path, err)
@@ -435,7 +451,7 @@
// since _ identifiers are not entered into scopes.
if !obj.used {
path := obj.imported.path
- base := pathLib.Base(path)
+ base := pkgName(path)
if obj.name == base {
check.softErrorf(obj.pos, "%q imported but not used", path)
} else {
@@ -453,3 +469,25 @@
}
}
}
+
+// pkgName returns the package name (last element) of an import path.
+func pkgName(path string) string {
+ if i := strings.LastIndex(path, "/"); i >= 0 {
+ path = path[i+1:]
+ }
+ return path
+}
+
+// dir makes a good-faith attempt to return the directory
+// portion of path. If path is empty, the result is ".".
+// (Per the go/build package dependency tests, we cannot import
+// path/filepath and simply use filepath.Dir.)
+func dir(path string) string {
+ if i := strings.LastIndexAny(path, "/\\"); i >= 0 {
+ path = path[:i]
+ }
+ if path == "" {
+ path = "."
+ }
+ return path
+}
diff --git a/src/go/types/resolver_test.go b/src/go/types/resolver_test.go
index 34deae2..4bb63b6 100644
--- a/src/go/types/resolver_test.go
+++ b/src/go/types/resolver_test.go
@@ -18,16 +18,23 @@
)
type resolveTestImporter struct {
- importer Importer
+ importer ImporterFrom
imported map[string]bool
}
-func (imp *resolveTestImporter) Import(path string) (*Package, error) {
+func (imp *resolveTestImporter) Import(string) (*Package, error) {
+ panic("should not be called")
+}
+
+func (imp *resolveTestImporter) ImportFrom(path, srcDir string, mode ImportMode) (*Package, error) {
+ if mode != 0 {
+ panic("mode must be 0")
+ }
if imp.importer == nil {
- imp.importer = importer.Default()
+ imp.importer = importer.Default().(ImporterFrom)
imp.imported = make(map[string]bool)
}
- pkg, err := imp.importer.Import(path)
+ pkg, err := imp.importer.ImportFrom(path, srcDir, mode)
if err != nil {
return nil, err
}
diff --git a/src/hash/crc32/crc32_amd64.s b/src/hash/crc32/crc32_amd64.s
index 11d9bb5..caacfae 100644
--- a/src/hash/crc32/crc32_amd64.s
+++ b/src/hash/crc32/crc32_amd64.s
@@ -225,9 +225,7 @@
PCLMULQDQ $0, X0, X1
PXOR X2, X1
- /* PEXTRD $1, X1, AX (SSE 4.1) */
- BYTE $0x66; BYTE $0x0f; BYTE $0x3a;
- BYTE $0x16; BYTE $0xc8; BYTE $0x01;
+ PEXTRD $1, X1, AX
MOVL AX, ret+32(FP)
RET
diff --git a/src/internal/syscall/windows/syscall_windows.go b/src/internal/syscall/windows/syscall_windows.go
index e5c1cd6..165e894 100644
--- a/src/internal/syscall/windows/syscall_windows.go
+++ b/src/internal/syscall/windows/syscall_windows.go
@@ -139,5 +139,5 @@
return MoveFileEx(from, to, MOVEFILE_REPLACE_EXISTING)
}
-//sys GetACP() (acp uint, err error) = kernel32.GetACP
-//sys MultiByteToWideChar(codePage uint, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int, err error) = kernel32.MultiByteToWideChar
+//sys GetACP() (acp uint32) = kernel32.GetACP
+//sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar
diff --git a/src/internal/syscall/windows/zsyscall_windows.go b/src/internal/syscall/windows/zsyscall_windows.go
index fd614f8..de41786 100644
--- a/src/internal/syscall/windows/zsyscall_windows.go
+++ b/src/internal/syscall/windows/zsyscall_windows.go
@@ -50,23 +50,16 @@
return
}
-func MultiByteToWideChar(codePage uint, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int, err error) {
- r0, _, e1 := syscall.Syscall6(procMultiByteToWideChar.Addr(), 6, uintptr(codePage), uintptr(dwFlags), uintptr(unsafe.Pointer(str)), uintptr(nstr), uintptr(unsafe.Pointer(wchar)), uintptr(nwchar))
- nwrite = int(r0)
- if nwrite == 0 {
- if e1 != 0 {
- err = error(e1)
- } else {
- err = syscall.EINVAL
- }
- }
+func GetACP() (acp uint32) {
+ r0, _, _ := syscall.Syscall(procGetACP.Addr(), 0, 0, 0, 0)
+ acp = uint32(r0)
return
}
-func GetACP() (acp uint, err error) {
- r0, _, e1 := syscall.Syscall(procGetACP.Addr(), 0, 0, 0, 0)
- acp = uint(r0)
- if acp == 0 {
+func MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) {
+ r0, _, e1 := syscall.Syscall6(procMultiByteToWideChar.Addr(), 6, uintptr(codePage), uintptr(dwFlags), uintptr(unsafe.Pointer(str)), uintptr(nstr), uintptr(unsafe.Pointer(wchar)), uintptr(nwchar))
+ nwrite = int32(r0)
+ if nwrite == 0 {
if e1 != 0 {
err = error(e1)
} else {
diff --git a/src/math/big/int.go b/src/math/big/int.go
index 16b7cd1..67ab704 100644
--- a/src/math/big/int.go
+++ b/src/math/big/int.go
@@ -273,7 +273,7 @@
// DivMod implements Euclidean division and modulus (unlike Go):
//
// q = x div y such that
-// m = x - y*q with 0 <= m < |q|
+// m = x - y*q with 0 <= m < |y|
//
// (See Raymond T. Boute, ``The Euclidean definition of the functions
// div and mod''. ACM Transactions on Programming Languages and
diff --git a/src/math/big/int_test.go b/src/math/big/int_test.go
index 2f55a7e..45a3765 100644
--- a/src/math/big/int_test.go
+++ b/src/math/big/int_test.go
@@ -566,6 +566,12 @@
"0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73",
"21484252197776302499639938883777710321993113097987201050501182909581359357618579566746556372589385361683610524730509041328855066514963385522570894839035884713051640171474186548713546686476761306436434146475140156284389181808675016576845833340494848283681088886584219750554408060556769486628029028720727393293111678826356480455433909233520504112074401376133077150471237549474149190242010469539006449596611576612573955754349042329130631128234637924786466585703488460540228477440853493392086251021228087076124706778899179648655221663765993962724699135217212118535057766739392069738618682722216712319320435674779146070442",
},
+
+ // test cases for issue 13907
+ {"0xffffffff00000001", "0xffffffff00000001", "0xffffffff00000001", "0"},
+ {"0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0"},
+ {"0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0"},
+ {"0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0"},
}
func TestExp(t *testing.T) {
@@ -593,7 +599,7 @@
t.Errorf("#%d: %v is not normalized", i, *z1)
}
if z1.Cmp(out) != 0 {
- t.Errorf("#%d: got %s want %s", i, z1, out)
+ t.Errorf("#%d: got %x want %x", i, z1, out)
}
if m == nil {
@@ -602,7 +608,7 @@
m = &Int{abs: nat{}} // m != nil && len(m.abs) == 0
z2 := new(Int).Exp(x, y, m)
if z2.Cmp(z1) != 0 {
- t.Errorf("#%d: got %s want %s", i, z2, z1)
+ t.Errorf("#%d: got %x want %x", i, z2, z1)
}
}
}
diff --git a/src/math/big/nat.go b/src/math/big/nat.go
index 71f85af..79cf6e0 100644
--- a/src/math/big/nat.go
+++ b/src/math/big/nat.go
@@ -1126,6 +1126,23 @@
}
// convert to regular number
zz = zz.montgomery(z, one, m, k0, numWords)
+
+ // One last reduction, just in case.
+ // See golang.org/issue/13907.
+ if zz.cmp(m) >= 0 {
+ // Common case is m has high bit set; in that case,
+ // since zz is the same length as m, there can be just
+ // one multiple of m to remove. Just subtract.
+ // We think that the subtract should be sufficient in general,
+ // so do that unconditionally, but double-check,
+ // in case our beliefs are wrong.
+ // The div is not expected to be reached.
+ zz = zz.sub(zz, m)
+ if zz.cmp(m) >= 0 {
+ _, zz = nat(nil).div(nil, zz, m)
+ }
+ }
+
return zz.norm()
}
diff --git a/src/net/dial.go b/src/net/dial.go
index 5586301..193776f 100644
--- a/src/net/dial.go
+++ b/src/net/dial.go
@@ -170,12 +170,14 @@
// in square brackets as in "[::1]:80" or "[ipv6-host%zone]:80".
// The functions JoinHostPort and SplitHostPort manipulate addresses
// in this form.
+// If the host is empty, as in ":80", the local system is assumed.
//
// Examples:
// Dial("tcp", "12.34.56.78:80")
// Dial("tcp", "google.com:http")
// Dial("tcp", "[2001:db8::1]:http")
// Dial("tcp", "[fe80::1%lo0]:80")
+// Dial("tcp", ":80")
//
// For IP networks, the network must be "ip", "ip4" or "ip6" followed
// by a colon and a protocol number or name and the addr must be a
@@ -388,7 +390,10 @@
// Listen announces on the local network address laddr.
// The network net must be a stream-oriented network: "tcp", "tcp4",
// "tcp6", "unix" or "unixpacket".
-// See Dial for the syntax of laddr.
+// For TCP and UDP, the syntax of laddr is "host:port", like "127.0.0.1:8080".
+// If host is omitted, as in ":8080", Listen listens on all available interfaces
+// instead of just the interface with the given host address.
+// See Dial for more details about address syntax.
func Listen(net, laddr string) (Listener, error) {
addrs, err := resolveAddrList("listen", net, laddr, noDeadline)
if err != nil {
@@ -412,6 +417,9 @@
// ListenPacket announces on the local network address laddr.
// The network net must be a packet-oriented network: "udp", "udp4",
// "udp6", "ip", "ip4", "ip6" or "unixgram".
+// For TCP and UDP, the syntax of laddr is "host:port", like "127.0.0.1:8080".
+// If host is omitted, as in ":8080", ListenPacket listens on all available interfaces
+// instead of just the interface with the given host address.
// See Dial for the syntax of laddr.
func ListenPacket(net, laddr string) (PacketConn, error) {
addrs, err := resolveAddrList("listen", net, laddr, noDeadline)
diff --git a/src/net/dnsclient.go b/src/net/dnsclient.go
index 0f4ef89..5dc2a03 100644
--- a/src/net/dnsclient.go
+++ b/src/net/dnsclient.go
@@ -165,8 +165,19 @@
// trailing dot to match pure Go reverse resolver and all other lookup
// routines.
// See golang.org/issue/12189.
+// But we don't want to add dots for local names from /etc/hosts.
+// It's hard to tell so we settle on the heuristic that names without dots
+// (like "localhost" or "myhost") do not get trailing dots, but any other
+// names do.
func absDomainName(b []byte) string {
- if len(b) > 0 && b[len(b)-1] != '.' {
+ hasDots := false
+ for _, x := range b {
+ if x == '.' {
+ hasDots = true
+ break
+ }
+ }
+ if hasDots && b[len(b)-1] != '.' {
b = append(b, '.')
}
return string(b)
diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go
index 5ef02a1..934f25b 100644
--- a/src/net/dnsclient_unix_test.go
+++ b/src/net/dnsclient_unix_test.go
@@ -80,7 +80,7 @@
server := "8.8.8.8:53"
for _, tt := range specialDomainNameTests {
- msg, err := exchange(server, tt.name, tt.qtype, 0)
+ msg, err := exchange(server, tt.name, tt.qtype, 3*time.Second)
if err != nil {
t.Error(err)
continue
diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go
index 4f7dac2..9c1aa79 100644
--- a/src/net/http/clientserver_test.go
+++ b/src/net/http/clientserver_test.go
@@ -14,6 +14,7 @@
"io"
"io/ioutil"
"log"
+ "net"
. "net/http"
"net/http/httptest"
"net/url"
@@ -22,7 +23,9 @@
"sort"
"strings"
"sync"
+ "sync/atomic"
"testing"
+ "time"
)
type clientServerTest struct {
@@ -44,7 +47,7 @@
h2Mode = true
)
-func newClientServerTest(t *testing.T, h2 bool, h Handler) *clientServerTest {
+func newClientServerTest(t *testing.T, h2 bool, h Handler, opts ...interface{}) *clientServerTest {
cst := &clientServerTest{
t: t,
h2: h2,
@@ -52,6 +55,16 @@
tr: &Transport{},
}
cst.c = &Client{Transport: cst.tr}
+
+ for _, opt := range opts {
+ switch opt := opt.(type) {
+ case func(*Transport):
+ opt(cst.tr)
+ default:
+ t.Fatalf("unhandled option type %T", opt)
+ }
+ }
+
if !h2 {
cst.ts = httptest.NewServer(h)
return cst
@@ -136,6 +149,7 @@
Handler func(ResponseWriter, *Request) // required
ReqFunc reqFunc // optional
CheckResponse func(proto string, res *Response) // optional
+ Opts []interface{}
}
func (tt h12Compare) reqFunc() reqFunc {
@@ -146,9 +160,9 @@
}
func (tt h12Compare) run(t *testing.T) {
- cst1 := newClientServerTest(t, false, HandlerFunc(tt.Handler))
+ cst1 := newClientServerTest(t, false, HandlerFunc(tt.Handler), tt.Opts...)
defer cst1.close()
- cst2 := newClientServerTest(t, true, HandlerFunc(tt.Handler))
+ cst2 := newClientServerTest(t, true, HandlerFunc(tt.Handler), tt.Opts...)
defer cst2.close()
res1, err := tt.reqFunc()(cst1.c, cst1.ts.URL)
@@ -377,6 +391,20 @@
}.run(t)
}
+func TestH12_AutoGzip_Disabled(t *testing.T) {
+ h12Compare{
+ Opts: []interface{}{
+ func(tr *Transport) { tr.DisableCompression = true },
+ },
+ Handler: func(w ResponseWriter, r *Request) {
+ fmt.Fprintf(w, "%q", r.Header["Accept-Encoding"])
+ if ae := r.Header.Get("Accept-Encoding"); ae != "" {
+ t.Errorf("%s Accept-Encoding = %q; want empty", r.Proto, ae)
+ }
+ },
+ }.run(t)
+}
+
// Test304Responses verifies that 304s don't declare that they're
// chunking in their response headers and aren't allowed to produce
// output.
@@ -418,6 +446,35 @@
}.run(t)
}
+func TestH12_RequestContentLength_Known_NonZero(t *testing.T) {
+ h12requestContentLength(t, func() io.Reader { return strings.NewReader("FOUR") }, 4)
+}
+
+func TestH12_RequestContentLength_Known_Zero(t *testing.T) {
+ h12requestContentLength(t, func() io.Reader { return strings.NewReader("") }, 0)
+}
+
+func TestH12_RequestContentLength_Unknown(t *testing.T) {
+ h12requestContentLength(t, func() io.Reader { return struct{ io.Reader }{strings.NewReader("Stuff")} }, -1)
+}
+
+func h12requestContentLength(t *testing.T, bodyfn func() io.Reader, wantLen int64) {
+ h12Compare{
+ Handler: func(w ResponseWriter, r *Request) {
+ w.Header().Set("Got-Length", fmt.Sprint(r.ContentLength))
+ fmt.Fprintf(w, "Req.ContentLength=%v", r.ContentLength)
+ },
+ ReqFunc: func(c *Client, url string) (*Response, error) {
+ return c.Post(url, "text/plain", bodyfn())
+ },
+ CheckResponse: func(proto string, res *Response) {
+ if got, want := res.Header.Get("Got-Length"), fmt.Sprint(wantLen); got != want {
+ t.Errorf("Proto %q got length %q; want %q", proto, got, want)
+ }
+ },
+ }.run(t)
+}
+
// Tests that closing the Request.Cancel channel also while still
// reading the response body. Issue 13159.
func TestCancelRequestMidBody_h1(t *testing.T) { testCancelRequestMidBody(t, h1Mode) }
@@ -792,3 +849,162 @@
}
}
}
+
+func TestStarRequestFoo_h1(t *testing.T) { testStarRequest(t, "FOO", h1Mode) }
+func TestStarRequestFoo_h2(t *testing.T) { testStarRequest(t, "FOO", h2Mode) }
+func TestStarRequestOptions_h1(t *testing.T) { testStarRequest(t, "OPTIONS", h1Mode) }
+func TestStarRequestOptions_h2(t *testing.T) { testStarRequest(t, "OPTIONS", h2Mode) }
+func testStarRequest(t *testing.T, method string, h2 bool) {
+ defer afterTest(t)
+ gotc := make(chan *Request, 1)
+ cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
+ w.Header().Set("foo", "bar")
+ gotc <- r
+ w.(Flusher).Flush()
+ }))
+ defer cst.close()
+
+ u, err := url.Parse(cst.ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+ u.Path = "*"
+
+ req := &Request{
+ Method: method,
+ Header: Header{},
+ URL: u,
+ }
+
+ res, err := cst.c.Do(req)
+ if err != nil {
+ t.Fatalf("RoundTrip = %v", err)
+ }
+ res.Body.Close()
+
+ wantFoo := "bar"
+ wantLen := int64(-1)
+ if method == "OPTIONS" {
+ wantFoo = ""
+ wantLen = 0
+ }
+ if res.StatusCode != 200 {
+ t.Errorf("status code = %v; want %d", res.Status, 200)
+ }
+ if res.ContentLength != wantLen {
+ t.Errorf("content length = %v; want %d", res.ContentLength, wantLen)
+ }
+ if got := res.Header.Get("foo"); got != wantFoo {
+ t.Errorf("response \"foo\" header = %q; want %q", got, wantFoo)
+ }
+ select {
+ case req = <-gotc:
+ default:
+ req = nil
+ }
+ if req == nil {
+ if method != "OPTIONS" {
+ t.Fatalf("handler never got request")
+ }
+ return
+ }
+ if req.Method != method {
+ t.Errorf("method = %q; want %q", req.Method, method)
+ }
+ if req.URL.Path != "*" {
+ t.Errorf("URL.Path = %q; want *", req.URL.Path)
+ }
+ if req.RequestURI != "*" {
+ t.Errorf("RequestURI = %q; want *", req.RequestURI)
+ }
+}
+
+// Issue 13957
+func TestTransportDiscardsUnneededConns(t *testing.T) {
+ defer afterTest(t)
+ cst := newClientServerTest(t, h2Mode, HandlerFunc(func(w ResponseWriter, r *Request) {
+ fmt.Fprintf(w, "Hello, %v", r.RemoteAddr)
+ }))
+ defer cst.close()
+
+ var numOpen, numClose int32 // atomic
+
+ tlsConfig := &tls.Config{InsecureSkipVerify: true}
+ tr := &Transport{
+ TLSClientConfig: tlsConfig,
+ DialTLS: func(_, addr string) (net.Conn, error) {
+ time.Sleep(10 * time.Millisecond)
+ rc, err := net.Dial("tcp", addr)
+ if err != nil {
+ return nil, err
+ }
+ atomic.AddInt32(&numOpen, 1)
+ c := noteCloseConn{rc, func() { atomic.AddInt32(&numClose, 1) }}
+ return tls.Client(c, tlsConfig), nil
+ },
+ }
+ if err := ExportHttp2ConfigureTransport(tr); err != nil {
+ t.Fatal(err)
+ }
+ defer tr.CloseIdleConnections()
+
+ c := &Client{Transport: tr}
+
+ const N = 10
+ gotBody := make(chan string, N)
+ var wg sync.WaitGroup
+ for i := 0; i < N; i++ {
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ resp, err := c.Get(cst.ts.URL)
+ if err != nil {
+ t.Errorf("Get: %v", err)
+ return
+ }
+ defer resp.Body.Close()
+ slurp, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ t.Error(err)
+ }
+ gotBody <- string(slurp)
+ }()
+ }
+ wg.Wait()
+ close(gotBody)
+
+ var last string
+ for got := range gotBody {
+ if last == "" {
+ last = got
+ continue
+ }
+ if got != last {
+ t.Errorf("Response body changed: %q -> %q", last, got)
+ }
+ }
+
+ var open, close int32
+ for i := 0; i < 150; i++ {
+ open, close = atomic.LoadInt32(&numOpen), atomic.LoadInt32(&numClose)
+ if open < 1 {
+ t.Fatalf("open = %d; want at least", open)
+ }
+ if close == open-1 {
+ // Success
+ return
+ }
+ time.Sleep(10 * time.Millisecond)
+ }
+ t.Errorf("%d connections opened, %d closed; want %d to close", open, close, open-1)
+}
+
+type noteCloseConn struct {
+ net.Conn
+ closeFunc func()
+}
+
+func (x noteCloseConn) Close() error {
+ x.closeFunc()
+ return x.Conn.Close()
+}
diff --git a/src/net/http/doc.go b/src/net/http/doc.go
index b1216e8..4ec8272 100644
--- a/src/net/http/doc.go
+++ b/src/net/http/doc.go
@@ -76,5 +76,20 @@
MaxHeaderBytes: 1 << 20,
}
log.Fatal(s.ListenAndServe())
+
+The http package has transparent support for the HTTP/2 protocol when
+using HTTPS. Programs that must disable HTTP/2 can do so by setting
+Transport.TLSNextProto (for clients) or Server.TLSNextProto (for
+servers) to a non-nil, empty map. Alternatively, the following GODEBUG
+environment variables are currently supported:
+
+ GODEBUG=http2client=0 # disable HTTP/2 client support
+ GODEBUG=http2server=0 # disable HTTP/2 server support
+ GODEBUG=http2debug=1 # enable verbose HTTP/2 debug logs
+ GODEBUG=http2debug=2 # ... even more verbose, with frame dumps
+
+The GODEBUG variables are not covered by Go's API compatibility promise.
+HTTP/2 support was added in Go 1.6. Please report any issues instead of
+disabling HTTP/2 support: https://golang.org/s/http2bug
*/
package http
diff --git a/src/net/http/export_test.go b/src/net/http/export_test.go
index 514d02b..52bccbd 100644
--- a/src/net/http/export_test.go
+++ b/src/net/http/export_test.go
@@ -21,6 +21,7 @@
ExportServerNewConn = (*Server).newConn
ExportCloseWriteAndWait = (*conn).closeWriteAndWait
ExportErrRequestCanceled = errRequestCanceled
+ ExportErrRequestCanceledConn = errRequestCanceledConn
ExportServeFile = serveFile
ExportHttp2ConfigureTransport = http2ConfigureTransport
ExportHttp2ConfigureServer = http2ConfigureServer
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index 7e7b494..cd530f1 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -47,21 +47,29 @@
MarkDead(*http2ClientConn)
}
+// TODO: use singleflight for dialing and addConnCalls?
type http2clientConnPool struct {
- t *http2Transport
+ t *http2Transport
+
mu sync.Mutex // TODO: maybe switch to RWMutex
// TODO: add support for sharing conns based on cert names
// (e.g. share conn for googleapis.com and appspot.com)
- conns map[string][]*http2ClientConn // key is host:port
- dialing map[string]*http2dialCall // currently in-flight dials
- keys map[*http2ClientConn][]string
+ conns map[string][]*http2ClientConn // key is host:port
+ dialing map[string]*http2dialCall // currently in-flight dials
+ keys map[*http2ClientConn][]string
+ addConnCalls map[string]*http2addConnCall // in-flight addConnIfNeede calls
}
func (p *http2clientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
- return p.getClientConn(req, addr, true)
+ return p.getClientConn(req, addr, http2dialOnMiss)
}
-func (p *http2clientConnPool) getClientConn(req *Request, addr string, dialOnMiss bool) (*http2ClientConn, error) {
+const (
+ http2dialOnMiss = true
+ http2noDialOnMiss = false
+)
+
+func (p *http2clientConnPool) getClientConn(_ *Request, addr string, dialOnMiss bool) (*http2ClientConn, error) {
p.mu.Lock()
for _, cc := range p.conns[addr] {
if cc.CanTakeNewRequest() {
@@ -115,6 +123,64 @@
c.p.mu.Unlock()
}
+// addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't
+// already exist. It coalesces concurrent calls with the same key.
+// This is used by the http1 Transport code when it creates a new connection. Because
+// the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know
+// the protocol), it can get into a situation where it has multiple TLS connections.
+// This code decides which ones live or die.
+// The return value used is whether c was used.
+// c is never closed.
+func (p *http2clientConnPool) addConnIfNeeded(key string, t *http2Transport, c *tls.Conn) (used bool, err error) {
+ p.mu.Lock()
+ for _, cc := range p.conns[key] {
+ if cc.CanTakeNewRequest() {
+ p.mu.Unlock()
+ return false, nil
+ }
+ }
+ call, dup := p.addConnCalls[key]
+ if !dup {
+ if p.addConnCalls == nil {
+ p.addConnCalls = make(map[string]*http2addConnCall)
+ }
+ call = &http2addConnCall{
+ p: p,
+ done: make(chan struct{}),
+ }
+ p.addConnCalls[key] = call
+ go call.run(t, key, c)
+ }
+ p.mu.Unlock()
+
+ <-call.done
+ if call.err != nil {
+ return false, call.err
+ }
+ return !dup, nil
+}
+
+type http2addConnCall struct {
+ p *http2clientConnPool
+ done chan struct{} // closed when done
+ err error
+}
+
+func (c *http2addConnCall) run(t *http2Transport, key string, tc *tls.Conn) {
+ cc, err := t.NewClientConn(tc)
+
+ p := c.p
+ p.mu.Lock()
+ if err != nil {
+ c.err = err
+ } else {
+ p.addConnLocked(key, cc)
+ }
+ delete(p.addConnCalls, key)
+ p.mu.Unlock()
+ close(c.done)
+}
+
func (p *http2clientConnPool) addConn(key string, cc *http2ClientConn) {
p.mu.Lock()
p.addConnLocked(key, cc)
@@ -181,11 +247,15 @@
return out
}
-func http2configureTransport(t1 *Transport) error {
+func http2configureTransport(t1 *Transport) (*http2Transport, error) {
connPool := new(http2clientConnPool)
- t2 := &http2Transport{ConnPool: http2noDialClientConnPool{connPool}}
+ t2 := &http2Transport{
+ ConnPool: http2noDialClientConnPool{connPool},
+ t1: t1,
+ }
+ connPool.t = t2
if err := http2registerHTTPSProtocol(t1, http2noDialH2RoundTripper{t2}); err != nil {
- return err
+ return nil, err
}
if t1.TLSClientConfig == nil {
t1.TLSClientConfig = new(tls.Config)
@@ -197,12 +267,14 @@
t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
}
upgradeFn := func(authority string, c *tls.Conn) RoundTripper {
- cc, err := t2.NewClientConn(c)
- if err != nil {
- c.Close()
+ addr := http2authorityAddr(authority)
+ if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
+ go c.Close()
return http2erringRoundTripper{err}
+ } else if !used {
+
+ go c.Close()
}
- connPool.addConn(http2authorityAddr(authority), cc)
return t2
}
if m := t1.TLSNextProto; len(m) == 0 {
@@ -212,7 +284,7 @@
} else {
m["h2"] = upgradeFn
}
- return nil
+ return t2, nil
}
// registerHTTPSProtocol calls Transport.RegisterProtocol but
@@ -233,8 +305,7 @@
type http2noDialClientConnPool struct{ *http2clientConnPool }
func (p http2noDialClientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
- const doDial = false
- return p.getClientConn(req, addr, doDial)
+ return p.getClientConn(req, addr, http2noDialOnMiss)
}
// noDialH2RoundTripper is a RoundTripper which only tries to complete the request
@@ -583,6 +654,12 @@
func (h http2FrameHeader) String() string {
var buf bytes.Buffer
buf.WriteString("[FrameHeader ")
+ h.writeDebug(&buf)
+ buf.WriteByte(']')
+ return buf.String()
+}
+
+func (h http2FrameHeader) writeDebug(buf *bytes.Buffer) {
buf.WriteString(h.Type.String())
if h.Flags != 0 {
buf.WriteString(" flags=")
@@ -599,15 +676,14 @@
if name != "" {
buf.WriteString(name)
} else {
- fmt.Fprintf(&buf, "0x%x", 1<<i)
+ fmt.Fprintf(buf, "0x%x", 1<<i)
}
}
}
if h.StreamID != 0 {
- fmt.Fprintf(&buf, " stream=%d", h.StreamID)
+ fmt.Fprintf(buf, " stream=%d", h.StreamID)
}
- fmt.Fprintf(&buf, " len=%d]", h.Length)
- return buf.String()
+ fmt.Fprintf(buf, " len=%d", h.Length)
}
func (h *http2FrameHeader) checkValid() {
@@ -700,6 +776,11 @@
// This is for testing and permits using the Framer to test
// other HTTP/2 implementations' conformance to the spec.
AllowIllegalReads bool
+
+ logReads bool
+
+ debugFramer *http2Framer // only use for logging written writes
+ debugFramerBuf *bytes.Buffer
}
func (f *http2Framer) startWrite(ftype http2FrameType, flags http2Flags, streamID uint32) {
@@ -726,6 +807,10 @@
byte(length>>16),
byte(length>>8),
byte(length))
+ if http2logFrameWrites {
+ f.logWrite()
+ }
+
n, err := f.w.Write(f.wbuf)
if err == nil && n != len(f.wbuf) {
err = io.ErrShortWrite
@@ -733,6 +818,23 @@
return err
}
+func (f *http2Framer) logWrite() {
+ if f.debugFramer == nil {
+ f.debugFramerBuf = new(bytes.Buffer)
+ f.debugFramer = http2NewFramer(nil, f.debugFramerBuf)
+ f.debugFramer.logReads = false
+
+ f.debugFramer.AllowIllegalReads = true
+ }
+ f.debugFramerBuf.Write(f.wbuf)
+ fr, err := f.debugFramer.ReadFrame()
+ if err != nil {
+ log.Printf("http2: Framer %p: failed to decode just-written frame", f)
+ return
+ }
+ log.Printf("http2: Framer %p: wrote %v", f, http2summarizeFrame(fr))
+}
+
func (f *http2Framer) writeByte(v byte) { f.wbuf = append(f.wbuf, v) }
func (f *http2Framer) writeBytes(v []byte) { f.wbuf = append(f.wbuf, v...) }
@@ -751,8 +853,9 @@
// NewFramer returns a Framer that writes frames to w and reads them from r.
func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
fr := &http2Framer{
- w: w,
- r: r,
+ w: w,
+ r: r,
+ logReads: http2logFrameReads,
}
fr.getReadBuf = func(size uint32) []byte {
if cap(fr.readBuf) >= int(size) {
@@ -821,6 +924,9 @@
if err := fr.checkFrameOrder(f); err != nil {
return nil, err
}
+ if fr.logReads {
+ log.Printf("http2: Framer %p: read %v", fr, http2summarizeFrame(f))
+ }
return f, nil
}
@@ -1563,6 +1669,49 @@
HeadersEnded() bool
}
+func http2summarizeFrame(f http2Frame) string {
+ var buf bytes.Buffer
+ f.Header().writeDebug(&buf)
+ switch f := f.(type) {
+ case *http2SettingsFrame:
+ n := 0
+ f.ForeachSetting(func(s http2Setting) error {
+ n++
+ if n == 1 {
+ buf.WriteString(", settings:")
+ }
+ fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
+ return nil
+ })
+ if n > 0 {
+ buf.Truncate(buf.Len() - 1)
+ }
+ case *http2DataFrame:
+ data := f.Data()
+ const max = 256
+ if len(data) > max {
+ data = data[:max]
+ }
+ fmt.Fprintf(&buf, " data=%q", data)
+ if len(f.Data()) > max {
+ fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
+ }
+ case *http2WindowUpdateFrame:
+ if f.StreamID == 0 {
+ buf.WriteString(" (conn)")
+ }
+ fmt.Fprintf(&buf, " incr=%v", f.Increment)
+ case *http2PingFrame:
+ fmt.Fprintf(&buf, " ping=%q", f.Data[:])
+ case *http2GoAwayFrame:
+ fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
+ f.LastStreamID, f.ErrCode, f.debugData)
+ case *http2RSTStreamFrame:
+ fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)
+ }
+ return buf.String()
+}
+
func http2requestCancel(req *Request) <-chan struct{} { return req.Cancel }
var http2DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
@@ -1784,7 +1933,23 @@
return strings.ToLower(v)
}
-var http2VerboseLogs = strings.Contains(os.Getenv("GODEBUG"), "h2debug=1")
+var (
+ http2VerboseLogs bool
+ http2logFrameWrites bool
+ http2logFrameReads bool
+)
+
+func init() {
+ e := os.Getenv("GODEBUG")
+ if strings.Contains(e, "http2debug=1") {
+ http2VerboseLogs = true
+ }
+ if strings.Contains(e, "http2debug=2") {
+ http2VerboseLogs = true
+ http2logFrameWrites = true
+ http2logFrameReads = true
+ }
+}
const (
// ClientPreface is the string that must be sent by new
@@ -2024,6 +2189,19 @@
return true
}
+type http2httpError struct {
+ msg string
+ timeout bool
+}
+
+func (e *http2httpError) Error() string { return e.msg }
+
+func (e *http2httpError) Timeout() bool { return e.timeout }
+
+func (e *http2httpError) Temporary() bool { return true }
+
+var http2errTimeout error = &http2httpError{msg: "http2: timeout awaiting response headers", timeout: true}
+
// pipe is a goroutine-safe io.Reader/io.Writer pair. It's like
// io.Pipe except there are no PipeReader/PipeWriter halves, and the
// underlying buffer is an interface. (io.Pipe is always unbuffered)
@@ -2374,7 +2552,7 @@
}
func (sc *http2serverConn) rejectConn(err http2ErrCode, debug string) {
- sc.vlogf("REJECTING conn: %v, %s", err, debug)
+ sc.vlogf("http2: server rejecting conn: %v, %s", err, debug)
sc.framer.WriteGoAway(0, err, []byte(debug))
sc.bw.Flush()
@@ -2559,7 +2737,9 @@
func (sc *http2serverConn) onNewHeaderField(f hpack.HeaderField) {
sc.serveG.check()
- sc.vlogf("got header field %+v", f)
+ if http2VerboseLogs {
+ sc.vlogf("http2: server decoded %v", f)
+ }
switch {
case !http2validHeader(f.Name):
sc.req.invalidHeader = true
@@ -2605,13 +2785,15 @@
func (st *http2stream) onNewTrailerField(f hpack.HeaderField) {
sc := st.sc
sc.serveG.check()
- sc.vlogf("got trailer field %+v", f)
+ if http2VerboseLogs {
+ sc.vlogf("http2: server decoded trailer %v", f)
+ }
switch {
case !http2validHeader(f.Name):
-
+ sc.req.invalidHeader = true
return
case strings.HasPrefix(f.Name, ":"):
-
+ sc.req.invalidHeader = true
return
default:
key := sc.canonicalHeader(f.Name)
@@ -2624,7 +2806,6 @@
if len(vv) >= tooBig {
sc.hpackDecoder.SetEmitEnabled(false)
}
-
}
}
}
@@ -2733,7 +2914,9 @@
defer sc.stopShutdownTimer()
defer close(sc.doneServing)
- sc.vlogf("HTTP/2 connection from %v on %p", sc.conn.RemoteAddr(), sc.hs)
+ if http2VerboseLogs {
+ sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs)
+ }
sc.writeFrame(http2frameWriteMsg{
write: http2writeSettings{
@@ -2745,7 +2928,7 @@
sc.unackedSettings++
if err := sc.readPreface(); err != nil {
- sc.condlogf(err, "error reading preface from client %v: %v", sc.conn.RemoteAddr(), err)
+ sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err)
return
}
@@ -2808,7 +2991,9 @@
return errors.New("timeout waiting for client preface")
case err := <-errc:
if err == nil {
- sc.vlogf("client %v said hello", sc.conn.RemoteAddr())
+ if http2VerboseLogs {
+ sc.vlogf("http2: server: client %v said hello", sc.conn.RemoteAddr())
+ }
}
return err
}
@@ -3064,7 +3249,9 @@
}
} else {
f := res.f
- sc.vlogf("got %v: %#v", f.Header(), f)
+ if http2VerboseLogs {
+ sc.vlogf("http2: server read frame %v", http2summarizeFrame(f))
+ }
err = sc.processFrame(f)
if err == nil {
return true
@@ -3079,14 +3266,14 @@
sc.goAway(http2ErrCodeFlowControl)
return true
case http2ConnectionError:
- sc.logf("%v: %v", sc.conn.RemoteAddr(), ev)
+ sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev)
sc.goAway(http2ErrCode(ev))
return true
default:
if res.err != nil {
- sc.logf("disconnecting; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
+ sc.logf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
} else {
- sc.logf("disconnection due to other error: %v", err)
+ sc.logf("http2: server closing client connection: %v", err)
}
return false
}
@@ -3123,7 +3310,7 @@
return http2ConnectionError(http2ErrCodeProtocol)
default:
- sc.vlogf("Ignoring frame: %v", f.Header())
+ sc.vlogf("http2: server ignoring frame: %v", f.Header())
return nil
}
}
@@ -3219,7 +3406,9 @@
if err := s.Valid(); err != nil {
return err
}
- sc.vlogf("processing setting %v", s)
+ if http2VerboseLogs {
+ sc.vlogf("http2: server processing setting %v", s)
+ }
switch s.ID {
case http2SettingHeaderTableSize:
sc.headerTableSize = s.Val
@@ -3236,6 +3425,9 @@
sc.peerMaxHeaderListSize = s.Val
default:
+ if http2VerboseLogs {
+ sc.vlogf("http2: server ignoring unknown setting %v", s)
+ }
}
return nil
}
@@ -3384,6 +3576,10 @@
return http2ConnectionError(http2ErrCodeProtocol)
}
st.gotTrailerHeader = true
+ if !f.StreamEnded() {
+ return http2StreamError{st.id, http2ErrCodeProtocol}
+ }
+ sc.resetPendingRequest()
return st.processTrailerHeaderBlockFragment(f.HeaderBlockFragment(), f.HeadersEnded())
}
@@ -3449,6 +3645,12 @@
if !end {
return nil
}
+
+ rp := &sc.req
+ if rp.invalidHeader {
+ return http2StreamError{rp.stream.id, http2ErrCodeProtocol}
+ }
+
err := sc.hpackDecoder.Close()
st.endStream()
if err != nil {
@@ -3571,7 +3773,6 @@
requestURI = rp.authority
} else {
var err error
-
url_, err = url.ParseRequestURI(rp.path)
if err != nil {
return nil, nil, http2StreamError{rp.stream.id, http2ErrCodeProtocol}
@@ -4128,16 +4329,36 @@
// uncompressed.
DisableCompression bool
+ // MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
+ // send in the initial settings frame. It is how many bytes
+ // of response headers are allow. Unlike the http2 spec, zero here
+ // means to use a default limit (currently 10MB). If you actually
+ // want to advertise an ulimited value to the peer, Transport
+ // interprets the highest possible value here (0xffffffff or 1<<32-1)
+ // to mean no limit.
+ MaxHeaderListSize uint32
+
+ // t1, if non-nil, is the standard library Transport using
+ // this transport. Its settings are used (but not its
+ // RoundTrip method, etc).
+ t1 *Transport
+
connPoolOnce sync.Once
connPoolOrDef http2ClientConnPool // non-nil version of ConnPool
}
-func (t *http2Transport) disableCompression() bool {
- if t.DisableCompression {
- return true
+func (t *http2Transport) maxHeaderListSize() uint32 {
+ if t.MaxHeaderListSize == 0 {
+ return 10 << 20
}
+ if t.MaxHeaderListSize == 0xffffffff {
+ return 0
+ }
+ return t.MaxHeaderListSize
+}
- return false
+func (t *http2Transport) disableCompression() bool {
+ return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
}
var http2errTransportVersion = errors.New("http2: ConfigureTransport is only supported starting at Go 1.6")
@@ -4146,7 +4367,8 @@
// It requires Go 1.6 or later and returns an error if the net/http package is too old
// or if t1 has already been HTTP/2-enabled.
func http2ConfigureTransport(t1 *Transport) error {
- return http2configureTransport(t1)
+ _, err := http2configureTransport(t1)
+ return err
}
func (t *http2Transport) connPool() http2ClientConnPool {
@@ -4192,7 +4414,7 @@
henc *hpack.Encoder
freeBuf [][]byte
- wmu sync.Mutex // held while writing; acquire AFTER wmu if holding both
+ wmu sync.Mutex // held while writing; acquire AFTER mu if holding both
werr error // first write error that has occurred
}
@@ -4210,7 +4432,7 @@
inflow http2flow // guarded by cc.mu
bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read
readErr error // sticky read error; owned by transportResponseBody.Read
- stopReqBody bool // stop writing req body; guarded by cc.mu
+ stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu
peerReset chan struct{} // closed on peer reset
resetErr error // populated before peerReset is closed
@@ -4221,8 +4443,8 @@
pastHeaders bool // got HEADERS w/ END_HEADERS
pastTrailers bool // got second HEADERS frame w/ END_HEADERS
- trailer Header // accumulated trailers
- resTrailer Header // client's Response.Trailer
+ trailer Header // accumulated trailers
+ resTrailer *Header // client's Response.Trailer
}
// awaitRequestCancel runs in its own goroutine and waits for the user
@@ -4253,10 +4475,13 @@
}
}
-func (cs *http2clientStream) abortRequestBodyWrite() {
+func (cs *http2clientStream) abortRequestBodyWrite(err error) {
+ if err == nil {
+ panic("nil error")
+ }
cc := cs.cc
cc.mu.Lock()
- cs.stopReqBody = true
+ cs.stopReqBody = err
cc.cond.Broadcast()
cc.mu.Unlock()
}
@@ -4309,7 +4534,7 @@
for {
cc, err := t.connPool().GetClientConn(req, addr)
if err != nil {
- t.vlogf("failed to get client conn: %v", err)
+ t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
return nil, err
}
res, err := cc.RoundTrip(req)
@@ -4395,9 +4620,15 @@
return cn, nil
}
+// disableKeepAlives reports whether connections should be closed as
+// soon as possible after handling the first request.
+func (t *http2Transport) disableKeepAlives() bool {
+ return t.t1 != nil && t.t1.DisableKeepAlives
+}
+
func (t *http2Transport) NewClientConn(c net.Conn) (*http2ClientConn, error) {
if http2VerboseLogs {
- t.vlogf("creating client conn to %v", c.RemoteAddr())
+ t.vlogf("http2: Transport creating client conn to %v", c.RemoteAddr())
}
if _, err := c.Write(http2clientPreface); err != nil {
t.vlogf("client preface write error: %v", err)
@@ -4420,6 +4651,7 @@
cc.bw = bufio.NewWriter(http2stickyErrWriter{c, &cc.werr})
cc.br = bufio.NewReader(c)
cc.fr = http2NewFramer(cc.bw, cc.br)
+
cc.henc = hpack.NewEncoder(&cc.hbuf)
type connectionStater interface {
@@ -4430,10 +4662,14 @@
cc.tlsState = &state
}
- cc.fr.WriteSettings(
+ initialSettings := []http2Setting{
http2Setting{ID: http2SettingEnablePush, Val: 0},
http2Setting{ID: http2SettingInitialWindowSize, Val: http2transportDefaultStreamFlow},
- )
+ }
+ if max := t.maxHeaderListSize(); max != 0 {
+ initialSettings = append(initialSettings, http2Setting{ID: http2SettingMaxHeaderListSize, Val: max})
+ }
+ cc.fr.WriteSettings(initialSettings...)
cc.fr.WriteWindowUpdate(0, http2transportDefaultConnFlow)
cc.inflow.add(http2transportDefaultConnFlow + http2initialWindowSize)
cc.bw.Flush()
@@ -4484,7 +4720,7 @@
}
func (cc *http2ClientConn) canTakeNewRequestLocked() bool {
- return cc.goAway == nil &&
+ return cc.goAway == nil && !cc.closed &&
int64(len(cc.streams)+1) < int64(cc.maxConcurrentStreams) &&
cc.nextStreamID < 2147483647
}
@@ -4564,6 +4800,14 @@
return "", nil
}
+func (cc *http2ClientConn) responseHeaderTimeout() time.Duration {
+ if cc.t.t1 != nil {
+ return cc.t.t1.ResponseHeaderTimeout
+ }
+
+ return 0
+}
+
func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) {
trailers, err := http2commaSeparatedTrailers(req)
if err != nil {
@@ -4571,6 +4815,25 @@
}
hasTrailers := trailers != ""
+ var body io.Reader = req.Body
+ contentLen := req.ContentLength
+ if req.Body != nil && contentLen == 0 {
+ // Test to see if it's actually zero or just unset.
+ var buf [1]byte
+ n, rerr := io.ReadFull(body, buf[:])
+ if rerr != nil && rerr != io.EOF {
+ contentLen = -1
+ body = http2errorReader{rerr}
+ } else if n == 1 {
+
+ contentLen = -1
+ body = io.MultiReader(bytes.NewReader(buf[:]), body)
+ } else {
+
+ body = nil
+ }
+ }
+
cc.mu.Lock()
if cc.closed || !cc.canTakeNewRequestLocked() {
cc.mu.Unlock()
@@ -4579,7 +4842,7 @@
cs := cc.newStream()
cs.req = req
- hasBody := req.Body != nil
+ hasBody := body != nil
if !cc.t.disableCompression() &&
req.Header.Get("Accept-Encoding") == "" &&
@@ -4589,7 +4852,7 @@
cs.requestedGzip = true
}
- hdrs := cc.encodeHeaders(req, cs.requestedGzip, trailers)
+ hdrs := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen)
cc.wmu.Lock()
endStream := !hasBody && !hasTrailers
werr := cc.writeHeaders(cs.ID, endStream, hdrs)
@@ -4605,24 +4868,32 @@
return nil, werr
}
+ var respHeaderTimer <-chan time.Time
var bodyCopyErrc chan error // result of body copy
if hasBody {
bodyCopyErrc = make(chan error, 1)
go func() {
- bodyCopyErrc <- cs.writeRequestBody(req.Body)
+ bodyCopyErrc <- cs.writeRequestBody(body, req.Body)
}()
+ } else {
+ if d := cc.responseHeaderTimeout(); d != 0 {
+ timer := time.NewTimer(d)
+ defer timer.Stop()
+ respHeaderTimer = timer.C
+ }
}
readLoopResCh := cs.resc
requestCanceledCh := http2requestCancel(req)
- requestCanceled := false
+ bodyWritten := false
+
for {
select {
case re := <-readLoopResCh:
res := re.res
if re.err != nil || res.StatusCode > 299 {
- cs.abortRequestBodyWrite()
+ cs.abortRequestBodyWrite(http2errStopReqBodyWrite)
}
if re.err != nil {
cc.forgetStreamID(cs.ID)
@@ -4631,32 +4902,35 @@
res.Request = req
res.TLS = cc.tlsState
return res, nil
+ case <-respHeaderTimer:
+ cc.forgetStreamID(cs.ID)
+ if !hasBody || bodyWritten {
+ cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
+ } else {
+ cs.abortRequestBodyWrite(http2errStopReqBodyWriteAndCancel)
+ }
+ return nil, http2errTimeout
case <-requestCanceledCh:
cc.forgetStreamID(cs.ID)
- cs.abortRequestBodyWrite()
- if !hasBody {
+ if !hasBody || bodyWritten {
cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
- return nil, http2errRequestCanceled
+ } else {
+ cs.abortRequestBodyWrite(http2errStopReqBodyWriteAndCancel)
}
-
- requestCanceled = true
- requestCanceledCh = nil
- readLoopResCh = nil
+ return nil, http2errRequestCanceled
case <-cs.peerReset:
- if requestCanceled {
-
- return nil, http2errRequestCanceled
- }
return nil, cs.resetErr
case err := <-bodyCopyErrc:
- if requestCanceled {
- cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
- return nil, http2errRequestCanceled
- }
if err != nil {
return nil, err
}
+ bodyWritten = true
+ if d := cc.responseHeaderTimeout(); d != 0 {
+ timer := time.NewTimer(d)
+ defer timer.Stop()
+ respHeaderTimer = timer.C
+ }
}
}
}
@@ -4689,11 +4963,16 @@
return cc.werr
}
-// errAbortReqBodyWrite is an internal error value.
-// It doesn't escape to callers.
-var http2errAbortReqBodyWrite = errors.New("http2: aborting request body write")
+// internal error values; they don't escape to callers
+var (
+ // abort request body write; don't send cancel
+ http2errStopReqBodyWrite = errors.New("http2: aborting request body write")
-func (cs *http2clientStream) writeRequestBody(body io.ReadCloser) (err error) {
+ // abort request body write, but send stream reset of cancel.
+ http2errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
+)
+
+func (cs *http2clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
cc := cs.cc
sentEnd := false
buf := cc.frameScratchBuffer()
@@ -4701,7 +4980,7 @@
defer func() {
- cerr := body.Close()
+ cerr := bodyCloser.Close()
if err == nil {
err = cerr
}
@@ -4724,7 +5003,13 @@
for len(remain) > 0 && err == nil {
var allowed int32
allowed, err = cs.awaitFlowControl(len(remain))
- if err != nil {
+ switch {
+ case err == http2errStopReqBodyWrite:
+ return err
+ case err == http2errStopReqBodyWriteAndCancel:
+ cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
+ return err
+ case err != nil:
return err
}
cc.wmu.Lock()
@@ -4778,8 +5063,8 @@
if cc.closed {
return 0, http2errClientConnClosed
}
- if cs.stopReqBody {
- return 0, http2errAbortReqBodyWrite
+ if cs.stopReqBody != nil {
+ return 0, cs.stopReqBody
}
if err := cs.checkReset(); err != nil {
return 0, err
@@ -4808,7 +5093,7 @@
func (e *http2badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) }
// requires cc.mu be held.
-func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trailers string) []byte {
+func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trailers string, contentLength int64) []byte {
cc.hbuf.Reset()
host := req.Host
@@ -4829,7 +5114,7 @@
var didUA bool
for k, vv := range req.Header {
lowKey := strings.ToLower(k)
- if lowKey == "host" {
+ if lowKey == "host" || lowKey == "content-length" {
continue
}
if lowKey == "user-agent" {
@@ -4847,6 +5132,9 @@
cc.writeHeader(lowKey, v)
}
}
+ if http2shouldSendReqContentLength(req.Method, contentLength) {
+ cc.writeHeader("content-length", strconv.FormatInt(contentLength, 10))
+ }
if addGzipHeader {
cc.writeHeader("accept-encoding", "gzip")
}
@@ -4856,6 +5144,27 @@
return cc.hbuf.Bytes()
}
+// shouldSendReqContentLength reports whether the http2.Transport should send
+// a "content-length" request header. This logic is basically a copy of the net/http
+// transferWriter.shouldSendContentLength.
+// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
+// -1 means unknown.
+func http2shouldSendReqContentLength(method string, contentLength int64) bool {
+ if contentLength > 0 {
+ return true
+ }
+ if contentLength < 0 {
+ return false
+ }
+
+ switch method {
+ case "POST", "PUT", "PATCH":
+ return true
+ default:
+ return false
+ }
+}
+
// requires cc.mu be held.
func (cc *http2ClientConn) encodeTrailers(req *Request) []byte {
cc.hbuf.Reset()
@@ -4870,6 +5179,9 @@
}
func (cc *http2ClientConn) writeHeader(name, value string) {
+ if http2VerboseLogs {
+ log.Printf("http2: Transport encoding header %q = %q", name, value)
+ }
cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
}
@@ -4904,7 +5216,7 @@
cc.mu.Lock()
defer cc.mu.Unlock()
cs := cc.streams[id]
- if andRemove && cs != nil {
+ if andRemove && cs != nil && !cc.closed {
delete(cc.streams, id)
close(cs.done)
}
@@ -4923,6 +5235,7 @@
sawRegHeader bool // saw non-pseudo header
reqMalformed error // non-nil once known to be malformed
lastHeaderEndsStream bool
+ headerListSize int64 // actually uint32, but easier math this way
}
// readLoop runs in its own goroutine and reads and dispatches frames.
@@ -4931,7 +5244,6 @@
cc: cc,
activeRes: make(map[uint32]*http2clientStream),
}
-
rl.hdec = hpack.NewDecoder(http2initialHeaderTableSize, rl.onNewHeaderField)
defer rl.cleanup()
@@ -4971,6 +5283,8 @@
func (rl *http2clientConnReadLoop) run() error {
cc := rl.cc
+ closeWhenIdle := cc.t.disableKeepAlives()
+ gotReply := false
for {
f, err := cc.fr.ReadFrame()
if err != nil {
@@ -4982,19 +5296,28 @@
} else if err != nil {
return err
}
- cc.vlogf("Transport received %v: %#v", f.Header(), f)
+ if http2VerboseLogs {
+ cc.vlogf("http2: Transport received %s", http2summarizeFrame(f))
+ }
+ maybeIdle := false
switch f := f.(type) {
case *http2HeadersFrame:
err = rl.processHeaders(f)
+ maybeIdle = true
+ gotReply = true
case *http2ContinuationFrame:
err = rl.processContinuation(f)
+ maybeIdle = true
case *http2DataFrame:
err = rl.processData(f)
+ maybeIdle = true
case *http2GoAwayFrame:
err = rl.processGoAway(f)
+ maybeIdle = true
case *http2RSTStreamFrame:
err = rl.processResetStream(f)
+ maybeIdle = true
case *http2SettingsFrame:
err = rl.processSettings(f)
case *http2PushPromiseFrame:
@@ -5009,6 +5332,9 @@
if err != nil {
return err
}
+ if closeWhenIdle && gotReply && maybeIdle && len(rl.activeRes) == 0 {
+ cc.closeIfIdle()
+ }
}
}
@@ -5016,11 +5342,13 @@
rl.sawRegHeader = false
rl.reqMalformed = nil
rl.lastHeaderEndsStream = f.StreamEnded()
+ rl.headerListSize = 0
rl.nextRes = &Response{
Proto: "HTTP/2.0",
ProtoMajor: 2,
Header: make(Header),
}
+ rl.hdec.SetEmitEnabled(true)
return rl.processHeaderBlockFragment(f.HeaderBlockFragment(), f.StreamID, f.HeadersEnded())
}
@@ -5037,7 +5365,7 @@
return nil
}
if cs.pastHeaders {
- rl.hdec.SetEmitFunc(cs.onNewTrailerField)
+ rl.hdec.SetEmitFunc(func(f hpack.HeaderField) { rl.onNewTrailerField(cs, f) })
} else {
rl.hdec.SetEmitFunc(rl.onNewHeaderField)
}
@@ -5116,7 +5444,7 @@
}
}
- cs.resTrailer = res.Trailer
+ cs.resTrailer = &res.Trailer
rl.activeRes[cs.ID] = cs
cs.resc <- http2resAndError{res: res}
rl.nextRes = nil
@@ -5205,24 +5533,36 @@
cc := rl.cc
cs := cc.streamByID(f.StreamID, f.StreamEnded())
if cs == nil {
+ cc.mu.Lock()
+ neverSent := cc.nextStreamID
+ cc.mu.Unlock()
+ if f.StreamID >= neverSent {
+
+ cc.logf("http2: Transport received unsolicited DATA frame; closing connection")
+ return http2ConnectionError(http2ErrCodeProtocol)
+ }
+
return nil
}
- data := f.Data()
- if http2VerboseLogs {
- rl.cc.logf("DATA: %q", data)
- }
+ if data := f.Data(); len(data) > 0 {
+ if cs.bufPipe.b == nil {
- cc.mu.Lock()
- if cs.inflow.available() >= int32(len(data)) {
- cs.inflow.take(int32(len(data)))
- } else {
+ cc.logf("http2: Transport received DATA frame for closed stream; closing connection")
+ return http2ConnectionError(http2ErrCodeProtocol)
+ }
+
+ cc.mu.Lock()
+ if cs.inflow.available() >= int32(len(data)) {
+ cs.inflow.take(int32(len(data)))
+ } else {
+ cc.mu.Unlock()
+ return http2ConnectionError(http2ErrCodeFlowControl)
+ }
cc.mu.Unlock()
- return http2ConnectionError(http2ErrCodeFlowControl)
- }
- cc.mu.Unlock()
- if _, err := cs.bufPipe.Write(data); err != nil {
- return err
+ if _, err := cs.bufPipe.Write(data); err != nil {
+ return err
+ }
}
if f.StreamEnded() {
@@ -5231,15 +5571,27 @@
return nil
}
+var http2errInvalidTrailers = errors.New("http2: invalid trailers")
+
func (rl *http2clientConnReadLoop) endStream(cs *http2clientStream) {
- cs.bufPipe.closeWithErrorAndCode(io.EOF, cs.copyTrailers)
+ err := io.EOF
+ code := cs.copyTrailers
+ if rl.reqMalformed != nil {
+ err = rl.reqMalformed
+ code = nil
+ }
+ cs.bufPipe.closeWithErrorAndCode(err, code)
delete(rl.activeRes, cs.ID)
}
func (cs *http2clientStream) copyTrailers() {
for k, vv := range cs.trailer {
- cs.resTrailer[k] = vv
+ t := cs.resTrailer
+ if *t == nil {
+ *t = make(Header)
+ }
+ (*t)[k] = vv
}
}
@@ -5343,20 +5695,57 @@
cc.wmu.Unlock()
}
-// onNewHeaderField runs on the readLoop goroutine whenever a new
-// hpack header field is decoded.
-func (rl *http2clientConnReadLoop) onNewHeaderField(f hpack.HeaderField) {
- cc := rl.cc
- if http2VerboseLogs {
- cc.logf("Header field: %+v", f)
+var (
+ http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
+ http2errInvalidHeaderKey = errors.New("http2: invalid header key")
+ http2errPseudoTrailers = errors.New("http2: invalid pseudo header in trailers")
+)
+
+func (rl *http2clientConnReadLoop) checkHeaderField(f hpack.HeaderField) bool {
+ if rl.reqMalformed != nil {
+ return false
+ }
+
+ const headerFieldOverhead = 32 // per spec
+ rl.headerListSize += int64(len(f.Name)) + int64(len(f.Value)) + headerFieldOverhead
+ if max := rl.cc.t.maxHeaderListSize(); max != 0 && rl.headerListSize > int64(max) {
+ rl.hdec.SetEmitEnabled(false)
+ rl.reqMalformed = http2errResponseHeaderListSize
+ return false
+ }
+
+ if !http2validHeader(f.Name) {
+ rl.reqMalformed = http2errInvalidHeaderKey
+ return false
}
isPseudo := strings.HasPrefix(f.Name, ":")
if isPseudo {
if rl.sawRegHeader {
rl.reqMalformed = errors.New("http2: invalid pseudo header after regular header")
- return
+ return false
}
+ } else {
+ rl.sawRegHeader = true
+ }
+
+ return true
+}
+
+// onNewHeaderField runs on the readLoop goroutine whenever a new
+// hpack header field is decoded.
+func (rl *http2clientConnReadLoop) onNewHeaderField(f hpack.HeaderField) {
+ cc := rl.cc
+ if http2VerboseLogs {
+ cc.logf("http2: Transport decoded %v", f)
+ }
+
+ if !rl.checkHeaderField(f) {
+ return
+ }
+
+ isPseudo := strings.HasPrefix(f.Name, ":")
+ if isPseudo {
switch f.Name {
case ":status":
code, err := strconv.Atoi(f.Value)
@@ -5370,39 +5759,48 @@
rl.reqMalformed = fmt.Errorf("http2: unknown response pseudo header %q", f.Name)
}
- } else {
- rl.sawRegHeader = true
- key := CanonicalHeaderKey(f.Name)
- if key == "Trailer" {
- t := rl.nextRes.Trailer
- if t == nil {
- t = make(Header)
- rl.nextRes.Trailer = t
- }
- http2foreachHeaderElement(f.Value, func(v string) {
- t[CanonicalHeaderKey(v)] = nil
- })
- } else {
- rl.nextRes.Header.Add(key, f.Value)
+ return
+ }
+
+ key := CanonicalHeaderKey(f.Name)
+ if key == "Trailer" {
+ t := rl.nextRes.Trailer
+ if t == nil {
+ t = make(Header)
+ rl.nextRes.Trailer = t
}
+ http2foreachHeaderElement(f.Value, func(v string) {
+ t[CanonicalHeaderKey(v)] = nil
+ })
+ } else {
+ rl.nextRes.Header.Add(key, f.Value)
}
}
-func (cs *http2clientStream) onNewTrailerField(f hpack.HeaderField) {
- isPseudo := strings.HasPrefix(f.Name, ":")
- if isPseudo {
-
+func (rl *http2clientConnReadLoop) onNewTrailerField(cs *http2clientStream, f hpack.HeaderField) {
+ if http2VerboseLogs {
+ rl.cc.logf("http2: Transport decoded trailer %v", f)
+ }
+ if !rl.checkHeaderField(f) {
return
}
+ if strings.HasPrefix(f.Name, ":") {
+
+ rl.reqMalformed = http2errPseudoTrailers
+ return
+ }
+
key := CanonicalHeaderKey(f.Name)
- if _, ok := cs.resTrailer[key]; ok {
+
+ // The spec says one must predeclare their trailers but in practice
+ // popular users (which is to say the only user we found) do not so we
+ // violate the spec and accept all of them.
+ const acceptAllTrailers = true
+ if _, ok := (*cs.resTrailer)[key]; ok || acceptAllTrailers {
if cs.trailer == nil {
cs.trailer = make(Header)
}
- const tooBig = 1000 // TODO: arbitrary; use max header list size limits
- if cur := cs.trailer[key]; len(cur) < tooBig {
- cs.trailer[key] = append(cur, f.Value)
- }
+ cs.trailer[key] = append(cs.trailer[key], f.Value)
}
}
@@ -5460,6 +5858,10 @@
return gz.body.Close()
}
+type http2errorReader struct{ err error }
+
+func (r http2errorReader) Read(p []byte) (int, error) { return 0, r.err }
+
// writeFramer is implemented by any type that is used to write frames.
type http2writeFramer interface {
writeFrame(http2writeContext) error
@@ -5580,27 +5982,31 @@
contentLength string
}
+func http2encKV(enc *hpack.Encoder, k, v string) {
+ if http2VerboseLogs {
+ log.Printf("http2: server encoding header %q = %q", k, v)
+ }
+ enc.WriteField(hpack.HeaderField{Name: k, Value: v})
+}
+
func (w *http2writeResHeaders) writeFrame(ctx http2writeContext) error {
enc, buf := ctx.HeaderEncoder()
buf.Reset()
if w.httpResCode != 0 {
- enc.WriteField(hpack.HeaderField{
- Name: ":status",
- Value: http2httpCodeString(w.httpResCode),
- })
+ http2encKV(enc, ":status", http2httpCodeString(w.httpResCode))
}
http2encodeHeaders(enc, w.h, w.trailers)
if w.contentType != "" {
- enc.WriteField(hpack.HeaderField{Name: "content-type", Value: w.contentType})
+ http2encKV(enc, "content-type", w.contentType)
}
if w.contentLength != "" {
- enc.WriteField(hpack.HeaderField{Name: "content-length", Value: w.contentLength})
+ http2encKV(enc, "content-length", w.contentLength)
}
if w.date != "" {
- enc.WriteField(hpack.HeaderField{Name: "date", Value: w.date})
+ http2encKV(enc, "date", w.date)
}
headerBlock := buf.Bytes()
@@ -5650,7 +6056,7 @@
func (w http2write100ContinueHeadersFrame) writeFrame(ctx http2writeContext) error {
enc, buf := ctx.HeaderEncoder()
buf.Reset()
- enc.WriteField(hpack.HeaderField{Name: ":status", Value: "100"})
+ http2encKV(enc, ":status", "100")
return ctx.Framer().WriteHeaders(http2HeadersFrameParam{
StreamID: w.streamID,
BlockFragment: buf.Bytes(),
@@ -5686,7 +6092,7 @@
if isTE && v != "trailers" {
continue
}
- enc.WriteField(hpack.HeaderField{Name: k, Value: v})
+ http2encKV(enc, k, v)
}
}
}
diff --git a/src/net/http/lex.go b/src/net/http/lex.go
index 50b14f8..52b6481 100644
--- a/src/net/http/lex.go
+++ b/src/net/http/lex.go
@@ -167,3 +167,17 @@
}
return true
}
+
+// isLWS reports whether b is linear white space, according
+// to http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2
+// LWS = [CRLF] 1*( SP | HT )
+func isLWS(b byte) bool { return b == ' ' || b == '\t' }
+
+// isCTL reports whether b is a control byte, according
+// to http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2
+// CTL = <any US-ASCII control character
+// (octets 0 - 31) and DEL (127)>
+func isCTL(b byte) bool {
+ const del = 0x7f // a CTL
+ return b < ' ' || b == del
+}
diff --git a/src/net/http/request.go b/src/net/http/request.go
index 28f0517..16c5bb4 100644
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -93,8 +93,8 @@
// The protocol version for incoming server requests.
//
// For client requests these fields are ignored. The HTTP
- // transport code uses either HTTP/1.1 or HTTP/2.0 by default,
- // depending on what the server supports.
+ // client code always uses either HTTP/1.1 or HTTP/2.
+ // See the docs on Transport for details.
Proto string // "HTTP/1.0"
ProtoMajor int // 1
ProtoMinor int // 0
@@ -1136,16 +1136,28 @@
return strings.IndexFunc(v, isNotToken) == -1
}
+// validHeaderValue reports whether v is a valid "field-value" according to
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2 :
+//
+// message-header = field-name ":" [ field-value ]
+// field-value = *( field-content | LWS )
+// field-content = <the OCTETs making up the field-value
+// and consisting of either *TEXT or combinations
+// of token, separators, and quoted-string>
+//
+// http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2 :
+//
+// TEXT = <any OCTET except CTLs,
+// but including LWS>
+// LWS = [CRLF] 1*( SP | HT )
+// CTL = <any US-ASCII control character
+// (octets 0 - 31) and DEL (127)>
func validHeaderValue(v string) bool {
for i := 0; i < len(v); i++ {
b := v[i]
- if b == '\t' {
- continue
+ if isCTL(b) && !isLWS(b) {
+ return false
}
- if ' ' <= b && b <= '~' {
- continue
- }
- return false
}
return true
}
diff --git a/src/net/http/response.go b/src/net/http/response.go
index 57ae364..c424f61 100644
--- a/src/net/http/response.go
+++ b/src/net/http/response.go
@@ -150,12 +150,14 @@
if len(f) > 2 {
reasonPhrase = f[2]
}
- resp.Status = f[1] + " " + reasonPhrase
- resp.StatusCode, err = strconv.Atoi(f[1])
- if err != nil {
+ if len(f[1]) != 3 {
return nil, &badStringError{"malformed HTTP status code", f[1]}
}
-
+ resp.StatusCode, err = strconv.Atoi(f[1])
+ if err != nil || resp.StatusCode < 0 {
+ return nil, &badStringError{"malformed HTTP status code", f[1]}
+ }
+ resp.Status = f[1] + " " + reasonPhrase
resp.Proto = f[0]
var ok bool
if resp.ProtoMajor, resp.ProtoMinor, ok = ParseHTTPVersion(resp.Proto); !ok {
diff --git a/src/net/http/response_test.go b/src/net/http/response_test.go
index d1c5a61..b4bf09a 100644
--- a/src/net/http/response_test.go
+++ b/src/net/http/response_test.go
@@ -507,6 +507,8 @@
},
}
+// tests successful calls to ReadResponse, and inspects the returned Response.
+// For error cases, see TestReadResponseErrors below.
func TestReadResponse(t *testing.T) {
for i, tt := range respTests {
resp, err := ReadResponse(bufio.NewReader(strings.NewReader(tt.Raw)), tt.Resp.Request)
@@ -673,6 +675,7 @@
{"/foo", "http://bar.com/baz", "http://bar.com/foo", nil},
{"http://foo.com/", "http://bar.com/baz", "http://foo.com/", nil},
{"", "http://bar.com/baz", "", ErrNoLocation},
+ {"/bar", "", "/bar", nil},
}
func TestLocationResponse(t *testing.T) {
@@ -751,13 +754,106 @@
}
}
-func TestReadResponseUnexpectedEOF(t *testing.T) {
- br := bufio.NewReader(strings.NewReader("HTTP/1.1 301 Moved Permanently\r\n" +
- "Location: http://example.com"))
- _, err := ReadResponse(br, nil)
- if err != io.ErrUnexpectedEOF {
- t.Errorf("ReadResponse = %v; want io.ErrUnexpectedEOF", err)
+// Test various ReadResponse error cases. (also tests success cases, but mostly
+// it's about errors). This does not test anything involving the bodies. Only
+// the return value from ReadResponse itself.
+func TestReadResponseErrors(t *testing.T) {
+ type testCase struct {
+ name string // optional, defaults to in
+ in string
+ wantErr interface{} // nil, err value, or string substring
}
+
+ status := func(s string, wantErr interface{}) testCase {
+ if wantErr == true {
+ wantErr = "malformed HTTP status code"
+ }
+ return testCase{
+ name: fmt.Sprintf("status %q", s),
+ in: "HTTP/1.1 " + s + "\r\nFoo: bar\r\n\r\n",
+ wantErr: wantErr,
+ }
+ }
+
+ version := func(s string, wantErr interface{}) testCase {
+ if wantErr == true {
+ wantErr = "malformed HTTP version"
+ }
+ return testCase{
+ name: fmt.Sprintf("version %q", s),
+ in: s + " 200 OK\r\n\r\n",
+ wantErr: wantErr,
+ }
+ }
+
+ tests := []testCase{
+ {"", "", io.ErrUnexpectedEOF},
+ {"", "HTTP/1.1 301 Moved Permanently\r\nFoo: bar", io.ErrUnexpectedEOF},
+ {"", "HTTP/1.1", "malformed HTTP response"},
+ {"", "HTTP/2.0", "malformed HTTP response"},
+ status("20X Unknown", true),
+ status("abcd Unknown", true),
+ status("二百/两百 OK", true),
+ status(" Unknown", true),
+ status("c8 OK", true),
+ status("0x12d Moved Permanently", true),
+ status("200 OK", nil),
+ status("000 OK", nil),
+ status("001 OK", nil),
+ status("404 NOTFOUND", nil),
+ status("20 OK", true),
+ status("00 OK", true),
+ status("-10 OK", true),
+ status("1000 OK", true),
+ status("999 Done", nil),
+ status("-1 OK", true),
+ status("-200 OK", true),
+ version("HTTP/1.2", nil),
+ version("HTTP/2.0", nil),
+ version("HTTP/1.100000000002", true),
+ version("HTTP/1.-1", true),
+ version("HTTP/A.B", true),
+ version("HTTP/1", true),
+ version("http/1.1", true),
+ }
+ for i, tt := range tests {
+ br := bufio.NewReader(strings.NewReader(tt.in))
+ _, rerr := ReadResponse(br, nil)
+ if err := matchErr(rerr, tt.wantErr); err != nil {
+ name := tt.name
+ if name == "" {
+ name = fmt.Sprintf("%i. input %q", i, tt.in)
+ }
+ t.Errorf("%s: %v", name, err)
+ }
+ }
+}
+
+// wantErr can be nil, an error value to match exactly, or type string to
+// match a substring.
+func matchErr(err error, wantErr interface{}) error {
+ if err == nil {
+ if wantErr == nil {
+ return nil
+ }
+ if sub, ok := wantErr.(string); ok {
+ return fmt.Errorf("unexpected success; want error with substring %q", sub)
+ }
+ return fmt.Errorf("unexpected success; want error %v", wantErr)
+ }
+ if wantErr == nil {
+ return fmt.Errorf("%v; want success", err)
+ }
+ if sub, ok := wantErr.(string); ok {
+ if strings.Contains(err.Error(), sub) {
+ return nil
+ }
+ return fmt.Errorf("error = %v; want an error with substring %q", err, sub)
+ }
+ if err == wantErr {
+ return nil
+ }
+ return fmt.Errorf("%v; want %v", err, wantErr)
}
func TestNeedsSniff(t *testing.T) {
diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 34e2a4d..f8cad80 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -1906,6 +1906,41 @@
}
}
+// Test different URL formats and schemes
+func TestRedirectURLFormat(t *testing.T) {
+ req, _ := NewRequest("GET", "http://example.com/qux/", nil)
+
+ var tests = []struct {
+ in string
+ want string
+ }{
+ // normal http
+ {"http://foobar.com/baz", "http://foobar.com/baz"},
+ // normal https
+ {"https://foobar.com/baz", "https://foobar.com/baz"},
+ // custom scheme
+ {"test://foobar.com/baz", "test://foobar.com/baz"},
+ // schemeless
+ {"//foobar.com/baz", "//foobar.com/baz"},
+ // relative to the root
+ {"/foobar.com/baz", "/foobar.com/baz"},
+ // relative to the current path
+ {"foobar.com/baz", "/qux/foobar.com/baz"},
+ // relative to the current path (+ going upwards)
+ {"../quux/foobar.com/baz", "/quux/foobar.com/baz"},
+ // incorrect number of slashes
+ {"///foobar.com/baz", "/foobar.com/baz"},
+ }
+
+ for _, tt := range tests {
+ rec := httptest.NewRecorder()
+ Redirect(rec, req, tt.in, 302)
+ if got := rec.Header().Get("Location"); got != tt.want {
+ t.Errorf("Redirect(%q) generated Location header %q; want %q", tt.in, got, tt.want)
+ }
+ }
+}
+
// TestZeroLengthPostAndResponse exercises an optimization done by the Transport:
// when there is no body (either because the method doesn't permit a body, or an
// explicit Content-Length of zero is present), then the transport can re-use the
@@ -3639,6 +3674,33 @@
}
}
+func TestIssue13893_Expect100(t *testing.T) {
+ // test that the Server doesn't filter out Expect headers.
+ req := reqBytes(`PUT /readbody HTTP/1.1
+User-Agent: PycURL/7.22.0
+Host: 127.0.0.1:9000
+Accept: */*
+Expect: 100-continue
+Content-Length: 10
+
+HelloWorld
+
+`)
+ var buf bytes.Buffer
+ conn := &rwTestConn{
+ Reader: bytes.NewReader(req),
+ Writer: &buf,
+ closec: make(chan bool, 1),
+ }
+ ln := &oneConnListener{conn: conn}
+ go Serve(ln, HandlerFunc(func(w ResponseWriter, r *Request) {
+ if _, ok := r.Header["Expect"]; !ok {
+ t.Error("Expect header should not be filtered out")
+ }
+ }))
+ <-conn.closec
+}
+
func TestIssue11549_Expect100(t *testing.T) {
req := reqBytes(`PUT /readbody HTTP/1.1
User-Agent: PycURL/7.22.0
@@ -3765,7 +3827,7 @@
{"HTTP/1.0", "Host: \xff\r\n", 400},
}
for _, tt := range tests {
- conn := &testConn{closec: make(chan bool)}
+ conn := &testConn{closec: make(chan bool, 1)}
io.WriteString(&conn.readBuf, "GET / "+tt.proto+"\r\n"+tt.host+"\r\n")
ln := &oneConnListener{conn}
@@ -3798,11 +3860,14 @@
{"foo\xffbar: foo\r\n", 400}, // binary in header
{"foo\x00bar: foo\r\n", 400}, // binary in header
- {"foo: foo\x00foo\r\n", 400}, // binary in value
- {"foo: foo\xfffoo\r\n", 400}, // binary in value
+ {"foo: foo foo\r\n", 200}, // LWS space is okay
+ {"foo: foo\tfoo\r\n", 200}, // LWS tab is okay
+ {"foo: foo\x00foo\r\n", 400}, // CTL 0x00 in value is bad
+ {"foo: foo\x7ffoo\r\n", 400}, // CTL 0x7f in value is bad
+ {"foo: foo\xfffoo\r\n", 200}, // non-ASCII high octets in value are fine
}
for _, tt := range tests {
- conn := &testConn{closec: make(chan bool)}
+ conn := &testConn{closec: make(chan bool, 1)}
io.WriteString(&conn.readBuf, "GET / HTTP/1.1\r\nHost: foo\r\n"+tt.header+"\r\n")
ln := &oneConnListener{conn}
diff --git a/src/net/http/server.go b/src/net/http/server.go
index 5bbd05e..2ec1069 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -347,7 +347,7 @@
// written.
trailers []string
- handlerDone bool // set true when the handler exits
+ handlerDone atomicBool // set true when the handler exits
// Buffers for Date and Content-Length
dateBuf [len(TimeFormat)]byte
@@ -358,6 +358,11 @@
closeNotifyCh <-chan bool
}
+type atomicBool int32
+
+func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
+func (b *atomicBool) setTrue() { atomic.StoreInt32((*int32)(b), 1) }
+
// declareTrailer is called for each Trailer header when the
// response header is written. It notes that a header will need to be
// written in the trailers at the end of the response.
@@ -911,7 +916,7 @@
// send a Content-Length header.
// Further, we don't send an automatic Content-Length if they
// set a Transfer-Encoding, because they're generally incompatible.
- if w.handlerDone && !trailers && !hasTE && bodyAllowedForStatus(w.status) && header.get("Content-Length") == "" && (!isHEAD || len(p) > 0) {
+ if w.handlerDone.isSet() && !trailers && !hasTE && bodyAllowedForStatus(w.status) && header.get("Content-Length") == "" && (!isHEAD || len(p) > 0) {
w.contentLength = int64(len(p))
setHeader.contentLength = strconv.AppendInt(cw.res.clenBuf[:0], int64(len(p)), 10)
}
@@ -1234,7 +1239,7 @@
}
func (w *response) finishRequest() {
- w.handlerDone = true
+ w.handlerDone.setTrue()
if !w.wroteHeader {
w.WriteHeader(StatusOK)
@@ -1452,7 +1457,6 @@
// Wrap the Body reader with one that replies on the connection
req.Body = &expectContinueReader{readCloser: req.Body, resp: w}
}
- req.Header.Del("Expect")
} else if req.Header.get("Expect") != "" {
w.sendExpectationFailed()
return
@@ -1499,6 +1503,9 @@
// Hijack implements the Hijacker.Hijack method. Our response is both a ResponseWriter
// and a Hijacker.
func (w *response) Hijack() (rwc net.Conn, buf *bufio.ReadWriter, err error) {
+ if w.handlerDone.isSet() {
+ panic("net/http: Hijack called after ServeHTTP finished")
+ }
if w.wroteHeader {
w.cw.flush()
}
@@ -1522,6 +1529,9 @@
}
func (w *response) CloseNotify() <-chan bool {
+ if w.handlerDone.isSet() {
+ panic("net/http: CloseNotify called after ServeHTTP finished")
+ }
c := w.conn
c.mu.Lock()
defer c.mu.Unlock()
@@ -1666,11 +1676,12 @@
// Because of this problem, no one pays attention
// to the RFC; they all send back just a new path.
// So do we.
- oldpath := r.URL.Path
- if oldpath == "" { // should not happen, but avoid a crash if it does
- oldpath = "/"
- }
- if u.Scheme == "" {
+ if u.Scheme == "" && u.Host == "" {
+ oldpath := r.URL.Path
+ if oldpath == "" { // should not happen, but avoid a crash if it does
+ oldpath = "/"
+ }
+
// no leading http://server
if urlStr == "" || urlStr[0] != '/' {
// make relative path absolute
@@ -2016,6 +2027,11 @@
// and doesn't fire again until the request has been
// handled. After the request is handled, the state
// transitions to StateClosed, StateHijacked, or StateIdle.
+ // For HTTP/2, StateActive fires on the transition from zero
+ // to one active request, and only transitions away once all
+ // active requests are complete. That means that ConnState
+ // can not be used to do per-request work; ConnState only notes
+ // the overall state of the connection.
StateActive
// StateIdle represents a connection that has finished
@@ -2267,6 +2283,9 @@
// configured otherwise. (by setting srv.TLSNextProto non-nil)
// It must only be called via srv.nextProtoOnce (use srv.setupHTTP2).
func (srv *Server) onceSetNextProtoDefaults() {
+ if strings.Contains(os.Getenv("GODEBUG"), "http2server=0") {
+ return
+ }
// Enable HTTP/2 by default if the user hasn't otherwise
// configured their TLSNextProto map.
if srv.TLSNextProto == nil {
diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index 01e3a05..fc0ae36 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -57,6 +57,10 @@
//
// A Transport is a low-level primitive for making HTTP and HTTPS requests.
// For high-level functionality, such as cookies and redirects, see Client.
+//
+// Transport uses HTTP/1.1 for HTTP URLs and either HTTP/1.1 or HTTP/2
+// for HTTPS URLs, depending on whether the server supports HTTP/2.
+// See the package docs for more about HTTP/2.
type Transport struct {
idleMu sync.Mutex
wantIdle bool // user has requested to close all idle conns
@@ -142,24 +146,30 @@
// If TLSNextProto is nil, HTTP/2 support is enabled automatically.
TLSNextProto map[string]func(authority string, c *tls.Conn) RoundTripper
- nextProtoOnce sync.Once // guards initialization of TLSNextProto (onceSetNextProtoDefaults)
+ // nextProtoOnce guards initialization of TLSNextProto and
+ // h2transport (via onceSetNextProtoDefaults)
+ nextProtoOnce sync.Once
+ h2transport *http2Transport // non-nil if http2 wired up
// TODO: tunable on global max cached connections
// TODO: tunable on timeout on cached connections
+ // TODO: tunable on max per-host TCP dials in flight (Issue 13957)
}
// onceSetNextProtoDefaults initializes TLSNextProto.
// It must be called via t.nextProtoOnce.Do.
func (t *Transport) onceSetNextProtoDefaults() {
- if strings.Contains(os.Getenv("GODEBUG"), "h2client=0") {
+ if strings.Contains(os.Getenv("GODEBUG"), "http2client=0") {
return
}
if t.TLSNextProto != nil {
return
}
- err := http2ConfigureTransport(t)
+ t2, err := http2configureTransport(t)
if err != nil {
log.Printf("Error enabling Transport HTTP/2 support: %v", err)
+ } else {
+ t.h2transport = t2
}
}
@@ -367,6 +377,7 @@
// a "keep-alive" state. It does not interrupt any connections currently
// in use.
func (t *Transport) CloseIdleConnections() {
+ t.nextProtoOnce.Do(t.onceSetNextProtoDefaults)
t.idleMu.Lock()
m := t.idleConn
t.idleConn = nil
@@ -378,6 +389,9 @@
pconn.close(errCloseIdleConns)
}
}
+ if t2 := t.h2transport; t2 != nil {
+ t2.CloseIdleConnections()
+ }
}
// CancelRequest cancels an in-flight request by closing its connection.
@@ -618,9 +632,13 @@
return true
}
-func (t *Transport) dial(network, addr string) (c net.Conn, err error) {
+func (t *Transport) dial(network, addr string) (net.Conn, error) {
if t.Dial != nil {
- return t.Dial(network, addr)
+ c, err := t.Dial(network, addr)
+ if c == nil && err == nil {
+ err = errors.New("net/http: Transport.Dial hook returned (nil, nil)")
+ }
+ return c, err
}
return net.Dial(network, addr)
}
@@ -682,10 +700,10 @@
return pc, nil
case <-req.Cancel:
handlePendingDial()
- return nil, errors.New("net/http: request canceled while waiting for connection")
+ return nil, errRequestCanceledConn
case <-cancelc:
handlePendingDial()
- return nil, errors.New("net/http: request canceled while waiting for connection")
+ return nil, errRequestCanceledConn
}
}
@@ -705,7 +723,16 @@
if err != nil {
return nil, err
}
+ if pconn.conn == nil {
+ return nil, errors.New("net/http: Transport.DialTLS returned (nil, nil)")
+ }
if tc, ok := pconn.conn.(*tls.Conn); ok {
+ // Handshake here, in case DialTLS didn't. TLSNextProto below
+ // depends on it for knowing the connection state.
+ if err := tc.Handshake(); err != nil {
+ go pconn.conn.Close()
+ return nil, err
+ }
cs := tc.ConnectionState()
pconn.tlsState = &cs
}
@@ -1326,6 +1353,7 @@
var errTimeout error = &httpError{err: "net/http: timeout awaiting response headers", timeout: true}
var errClosed error = &httpError{err: "net/http: server closed connection before response was received"}
var errRequestCanceled = errors.New("net/http: request canceled")
+var errRequestCanceledConn = errors.New("net/http: request canceled while waiting for connection") // TODO: unify?
func nop() {}
@@ -1502,9 +1530,19 @@
}
pc.broken = true
if pc.closed == nil {
- pc.conn.Close()
pc.closed = err
- close(pc.closech)
+ if pc.alt != nil {
+ // Do nothing; can only get here via getConn's
+ // handlePendingDial's putOrCloseIdleConn when
+ // it turns out the abandoned connection in
+ // flight ended up negotiating an alternate
+ // protocol. We don't use the connection
+ // freelist for http2. That's done by the
+ // alternate protocol's RoundTripper.
+ } else {
+ pc.conn.Close()
+ close(pc.closech)
+ }
}
pc.mutateHeaderFunc = nil
}
diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 46e3303..3b2a5f9 100644
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -24,6 +24,7 @@
. "net/http"
"net/http/httptest"
"net/http/httputil"
+ "net/http/internal"
"net/url"
"os"
"reflect"
@@ -2939,6 +2940,98 @@
}
}
+// Issue 13839
+func TestNoCrashReturningTransportAltConn(t *testing.T) {
+ cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ ln := newLocalListener(t)
+ defer ln.Close()
+
+ handledPendingDial := make(chan bool, 1)
+ SetPendingDialHooks(nil, func() { handledPendingDial <- true })
+ defer SetPendingDialHooks(nil, nil)
+
+ testDone := make(chan struct{})
+ defer close(testDone)
+ go func() {
+ tln := tls.NewListener(ln, &tls.Config{
+ NextProtos: []string{"foo"},
+ Certificates: []tls.Certificate{cert},
+ })
+ sc, err := tln.Accept()
+ if err != nil {
+ t.Error(err)
+ return
+ }
+ if err := sc.(*tls.Conn).Handshake(); err != nil {
+ t.Error(err)
+ return
+ }
+ <-testDone
+ sc.Close()
+ }()
+
+ addr := ln.Addr().String()
+
+ req, _ := NewRequest("GET", "https://fake.tld/", nil)
+ cancel := make(chan struct{})
+ req.Cancel = cancel
+
+ doReturned := make(chan bool, 1)
+ madeRoundTripper := make(chan bool, 1)
+
+ tr := &Transport{
+ DisableKeepAlives: true,
+ TLSNextProto: map[string]func(string, *tls.Conn) RoundTripper{
+ "foo": func(authority string, c *tls.Conn) RoundTripper {
+ madeRoundTripper <- true
+ return funcRoundTripper(func() {
+ t.Error("foo RoundTripper should not be called")
+ })
+ },
+ },
+ Dial: func(_, _ string) (net.Conn, error) {
+ panic("shouldn't be called")
+ },
+ DialTLS: func(_, _ string) (net.Conn, error) {
+ tc, err := tls.Dial("tcp", addr, &tls.Config{
+ InsecureSkipVerify: true,
+ NextProtos: []string{"foo"},
+ })
+ if err != nil {
+ return nil, err
+ }
+ if err := tc.Handshake(); err != nil {
+ return nil, err
+ }
+ close(cancel)
+ <-doReturned
+ return tc, nil
+ },
+ }
+ c := &Client{Transport: tr}
+
+ _, err = c.Do(req)
+ if ue, ok := err.(*url.Error); !ok || ue.Err != ExportErrRequestCanceledConn {
+ t.Fatalf("Do error = %v; want url.Error with errRequestCanceledConn", err)
+ }
+
+ doReturned <- true
+ <-madeRoundTripper
+ <-handledPendingDial
+}
+
+var errFakeRoundTrip = errors.New("fake roundtrip")
+
+type funcRoundTripper func()
+
+func (fn funcRoundTripper) RoundTrip(*Request) (*Response, error) {
+ fn()
+ return nil, errFakeRoundTrip
+}
+
func wantBody(res *Response, err error, want string) error {
if err != nil {
return err
diff --git a/src/net/lookup_plan9.go b/src/net/lookup_plan9.go
index 56846bc..a331628 100644
--- a/src/net/lookup_plan9.go
+++ b/src/net/lookup_plan9.go
@@ -190,17 +190,6 @@
return 0, unknownPortError
}
-// ensureEndDot adds '.' at the end of name unless it is already there.
-func ensureEndDot(name string) string {
- if name == "" {
- return "."
- }
- if name[len(name)-1] == '.' {
- return name
- }
- return name + "."
-}
-
func lookupCNAME(name string) (cname string, err error) {
lines, err := queryDNS(name, "cname")
if err != nil {
@@ -236,8 +225,8 @@
if !(portOk && priorityOk && weightOk) {
continue
}
- addrs = append(addrs, &SRV{ensureEndDot(f[5]), uint16(port), uint16(priority), uint16(weight)})
- cname = ensureEndDot(f[0])
+ addrs = append(addrs, &SRV{absDomainName([]byte(f[5])), uint16(port), uint16(priority), uint16(weight)})
+ cname = absDomainName([]byte(f[0]))
}
byPriorityWeight(addrs).sort()
return
@@ -254,7 +243,7 @@
continue
}
if pref, _, ok := dtoi(f[2], 0); ok {
- mx = append(mx, &MX{ensureEndDot(f[3]), uint16(pref)})
+ mx = append(mx, &MX{absDomainName([]byte(f[3])), uint16(pref)})
}
}
byPref(mx).sort()
@@ -271,7 +260,7 @@
if len(f) < 3 {
continue
}
- ns = append(ns, &NS{ensureEndDot(f[2])})
+ ns = append(ns, &NS{absDomainName([]byte(f[2]))})
}
return
}
@@ -283,7 +272,7 @@
}
for _, line := range lines {
if i := byteIndex(line, '\t'); i >= 0 {
- txt = append(txt, ensureEndDot(line[i+1:]))
+ txt = append(txt, absDomainName([]byte(line[i+1:])))
}
}
return
@@ -303,7 +292,7 @@
if len(f) < 3 {
continue
}
- name = append(name, ensureEndDot(f[2]))
+ name = append(name, absDomainName([]byte(f[2])))
}
return
}
diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go
index fa2c636..677a5f5 100644
--- a/src/net/lookup_test.go
+++ b/src/net/lookup_test.go
@@ -7,6 +7,7 @@
import (
"bytes"
"fmt"
+ "internal/testenv"
"runtime"
"strings"
"testing"
@@ -57,7 +58,7 @@
}
func TestLookupGoogleSRV(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -91,7 +92,7 @@
}
func TestLookupGmailMX(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -122,7 +123,7 @@
}
func TestLookupGmailNS(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -153,7 +154,7 @@
}
func TestLookupGmailTXT(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -187,7 +188,7 @@
}
func TestLookupGooglePublicDNSAddr(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !supportsIPv6 || !*testIPv4 || !*testIPv6 {
@@ -211,7 +212,7 @@
}
func TestLookupIPv6LinkLocalAddr(t *testing.T) {
- if !supportsIPv6 {
+ if !supportsIPv6 || !*testIPv6 {
t.Skip("IPv6 is required")
}
@@ -242,7 +243,7 @@
}
func TestLookupIANACNAME(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -268,7 +269,7 @@
}
func TestLookupGoogleHost(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -299,7 +300,7 @@
}
func TestLookupGoogleIP(t *testing.T) {
- if testing.Short() || !*testExternal {
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
t.Skip("avoid external network")
}
if !supportsIPv4 || !*testIPv4 {
@@ -421,7 +422,7 @@
}
func TestLookupDotsWithLocalSource(t *testing.T) {
- if !supportsIPv4 {
+ if !supportsIPv4 || !*testIPv4 {
t.Skip("IPv4 is required")
}
@@ -433,20 +434,29 @@
names, err := LookupAddr("127.0.0.1")
fixup()
if err != nil {
- t.Errorf("#%d: %v", i, err)
+ t.Logf("#%d: %v", i, err)
continue
}
+ mode := "netgo"
+ if i == 1 {
+ mode = "netcgo"
+ }
for _, name := range names {
- if !strings.HasSuffix(name, ".") {
- t.Errorf("#%d: got %s; want name ending with trailing dot", i, name)
+ if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
+ t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1])
+ } else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain"
+ t.Errorf("%s: got %s; want name ending with trailing dot", mode, name)
}
}
}
}
func TestLookupDotsWithRemoteSource(t *testing.T) {
- if testing.Short() || !*testExternal {
- t.Skipf("skipping external network test")
+ if testing.Short() && testenv.Builder() == "" || !*testExternal {
+ t.Skip("avoid external network")
+ }
+ if !supportsIPv4 || *testIPv4 {
+ t.Skip("IPv4 is required")
}
if fixup := forceGoDNS(); fixup != nil {
diff --git a/src/net/lookup_windows.go b/src/net/lookup_windows.go
index 784763a..13edc26 100644
--- a/src/net/lookup_windows.go
+++ b/src/net/lookup_windows.go
@@ -19,7 +19,7 @@
func getprotobyname(name string) (proto int, err error) {
p, err := syscall.GetProtoByName(name)
if err != nil {
- return 0, os.NewSyscallError("getorotobyname", err)
+ return 0, os.NewSyscallError("getprotobyname", err)
}
return int(p.Proto), nil
}
@@ -213,17 +213,6 @@
return 0, &DNSError{Err: syscall.EINVAL.Error(), Name: network + "/" + service}
}
-// ensureEndDot adds '.' at the end of name unless it is already there.
-func ensureEndDot(name string) string {
- if name == "" {
- return "."
- }
- if name[len(name)-1] == '.' {
- return name
- }
- return name + "."
-}
-
func lookupCNAME(name string) (string, error) {
acquireThread()
defer releaseThread()
@@ -232,7 +221,7 @@
// windows returns DNS_INFO_NO_RECORDS if there are no CNAME-s
if errno, ok := e.(syscall.Errno); ok && errno == syscall.DNS_INFO_NO_RECORDS {
// if there are no aliases, the canonical name is the input name
- return ensureEndDot(name), nil
+ return absDomainName([]byte(name)), nil
}
if e != nil {
return "", &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: name}
@@ -241,7 +230,7 @@
resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), r)
cname := syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(resolved))[:])
- return ensureEndDot(cname), nil
+ return absDomainName([]byte(cname)), nil
}
func lookupSRV(service, proto, name string) (string, []*SRV, error) {
@@ -263,10 +252,10 @@
srvs := make([]*SRV, 0, 10)
for _, p := range validRecs(r, syscall.DNS_TYPE_SRV, target) {
v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
- srvs = append(srvs, &SRV{ensureEndDot(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:])), v.Port, v.Priority, v.Weight})
+ srvs = append(srvs, &SRV{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:]))), v.Port, v.Priority, v.Weight})
}
byPriorityWeight(srvs).sort()
- return ensureEndDot(target), srvs, nil
+ return absDomainName([]byte(target)), srvs, nil
}
func lookupMX(name string) ([]*MX, error) {
@@ -282,7 +271,7 @@
mxs := make([]*MX, 0, 10)
for _, p := range validRecs(r, syscall.DNS_TYPE_MX, name) {
v := (*syscall.DNSMXData)(unsafe.Pointer(&p.Data[0]))
- mxs = append(mxs, &MX{ensureEndDot(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.NameExchange))[:])), v.Preference})
+ mxs = append(mxs, &MX{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.NameExchange))[:]))), v.Preference})
}
byPref(mxs).sort()
return mxs, nil
@@ -301,7 +290,7 @@
nss := make([]*NS, 0, 10)
for _, p := range validRecs(r, syscall.DNS_TYPE_NS, name) {
v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
- nss = append(nss, &NS{ensureEndDot(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))})
+ nss = append(nss, &NS{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:])))})
}
return nss, nil
}
@@ -344,7 +333,7 @@
ptrs := make([]string, 0, 10)
for _, p := range validRecs(r, syscall.DNS_TYPE_PTR, arpa) {
v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
- ptrs = append(ptrs, ensureEndDot(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:])))
+ ptrs = append(ptrs, absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))))
}
return ptrs, nil
}
diff --git a/src/net/lookup_windows_test.go b/src/net/lookup_windows_test.go
index 1a01011..7ff32b8 100644
--- a/src/net/lookup_windows_test.go
+++ b/src/net/lookup_windows_test.go
@@ -177,14 +177,14 @@
rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+mail exchanger\s*=\s*([0-9]+)\s*([a-z0-9.\-]+)$`)
for _, ans := range rx.FindAllStringSubmatch(r, -1) {
pref, _, _ := dtoi(ans[2], 0)
- mx = append(mx, &MX{ensureEndDot(ans[3]), uint16(pref)})
+ mx = append(mx, &MX{absDomainName([]byte(ans[3])), uint16(pref)})
}
// windows nslookup syntax
// gmail.com MX preference = 30, mail exchanger = alt3.gmail-smtp-in.l.google.com
rx = regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+MX preference\s*=\s*([0-9]+)\s*,\s*mail exchanger\s*=\s*([a-z0-9.\-]+)$`)
for _, ans := range rx.FindAllStringSubmatch(r, -1) {
pref, _, _ := dtoi(ans[2], 0)
- mx = append(mx, &MX{ensureEndDot(ans[3]), uint16(pref)})
+ mx = append(mx, &MX{absDomainName([]byte(ans[3])), uint16(pref)})
}
return
}
@@ -198,7 +198,7 @@
// golang.org nameserver = ns1.google.com.
rx := regexp.MustCompile(`(?m)^([a-z0-9.\-]+)\s+nameserver\s*=\s*([a-z0-9.\-]+)$`)
for _, ans := range rx.FindAllStringSubmatch(r, -1) {
- ns = append(ns, &NS{ensureEndDot(ans[2])})
+ ns = append(ns, &NS{absDomainName([]byte(ans[2]))})
}
return
}
@@ -215,7 +215,7 @@
for _, ans := range rx.FindAllStringSubmatch(r, -1) {
last = ans[2]
}
- return ensureEndDot(last), nil
+ return absDomainName([]byte(last)), nil
}
func nslookupTXT(name string) (txt []string, err error) {
diff --git a/src/net/net_windows_test.go b/src/net/net_windows_test.go
index 2e9a0ae..e59dcd5 100644
--- a/src/net/net_windows_test.go
+++ b/src/net/net_windows_test.go
@@ -380,6 +380,8 @@
}
func TestInterfaceAddrsWithNetsh(t *testing.T) {
+ t.Skip("see https://golang.org/issue/13981")
+
if isWindowsXP(t) {
t.Skip("Windows XP netsh command does not provide required functionality")
}
diff --git a/src/net/non_unix_test.go b/src/net/non_unix_test.go
index b25e0f1..db3427e 100644
--- a/src/net/non_unix_test.go
+++ b/src/net/non_unix_test.go
@@ -6,6 +6,17 @@
package net
+import "runtime"
+
// See unix_test.go for what these (don't) do.
-func forceGoDNS() func() { return nil }
+func forceGoDNS() func() {
+ switch runtime.GOOS {
+ case "plan9", "windows":
+ return func() {}
+ default:
+ return nil
+ }
+}
+
+// See unix_test.go for what these (don't) do.
func forceCgoDNS() func() { return nil }
diff --git a/src/net/sendfile_solaris.go b/src/net/sendfile_solaris.go
index 0966575..f683381 100644
--- a/src/net/sendfile_solaris.go
+++ b/src/net/sendfile_solaris.go
@@ -26,6 +26,8 @@
//
// if handled == false, sendFile performed no work.
func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
+ return // Solaris sendfile is disabled until Issue 13892 is understood and fixed
+
// Solaris uses 0 as the "until EOF" value. If you pass in more bytes than the
// file contains, it will loop back to the beginning ad nauseam until it's sent
// exactly the number of bytes told to. As such, we need to know exactly how many
diff --git a/src/net/textproto/reader.go b/src/net/textproto/reader.go
index 17edfad..91bbb57 100644
--- a/src/net/textproto/reader.go
+++ b/src/net/textproto/reader.go
@@ -237,7 +237,12 @@
// separated by a newline (\n).
//
// See page 36 of RFC 959 (http://www.ietf.org/rfc/rfc959.txt) for
-// details.
+// details of another form of response accepted:
+//
+// code-message line 1
+// message line 2
+// ...
+// code message line n
//
// If the prefix of the status does not match the digits in expectCode,
// ReadResponse returns with err set to &Error{code, message}.
@@ -248,7 +253,8 @@
//
func (r *Reader) ReadResponse(expectCode int) (code int, message string, err error) {
code, continued, message, err := r.readCodeLine(expectCode)
- for err == nil && continued {
+ multi := continued
+ for continued {
line, err := r.ReadLine()
if err != nil {
return 0, "", err
@@ -256,7 +262,7 @@
var code2 int
var moreMessage string
- code2, continued, moreMessage, err = parseCodeLine(line, expectCode)
+ code2, continued, moreMessage, err = parseCodeLine(line, 0)
if err != nil || code2 != code {
message += "\n" + strings.TrimRight(line, "\r\n")
continued = true
@@ -264,6 +270,10 @@
}
message += "\n" + moreMessage
}
+ if err != nil && multi && message != "" {
+ // replace one line error message with all lines (full message)
+ err = &Error{code, message}
+ }
return
}
diff --git a/src/net/textproto/reader_test.go b/src/net/textproto/reader_test.go
index db7d8ab..9c71594 100644
--- a/src/net/textproto/reader_test.go
+++ b/src/net/textproto/reader_test.go
@@ -284,6 +284,35 @@
}
}
+// Test that multi-line errors are appropriately and fully read. Issue 10230.
+func TestReadMultiLineError(t *testing.T) {
+ r := reader("550-5.1.1 The email account that you tried to reach does not exist. Please try\n" +
+ "550-5.1.1 double-checking the recipient's email address for typos or\n" +
+ "550-5.1.1 unnecessary spaces. Learn more at\n" +
+ "Unexpected but legal text!\n" +
+ "550 5.1.1 https://support.google.com/mail/answer/6596 h20si25154304pfd.166 - gsmtp\n")
+
+ wantMsg := "5.1.1 The email account that you tried to reach does not exist. Please try\n" +
+ "5.1.1 double-checking the recipient's email address for typos or\n" +
+ "5.1.1 unnecessary spaces. Learn more at\n" +
+ "Unexpected but legal text!\n" +
+ "5.1.1 https://support.google.com/mail/answer/6596 h20si25154304pfd.166 - gsmtp"
+
+ code, msg, err := r.ReadResponse(250)
+ if err == nil {
+ t.Errorf("ReadResponse: no error, want error")
+ }
+ if code != 550 {
+ t.Errorf("ReadResponse: code=%d, want %d", code, 550)
+ }
+ if msg != wantMsg {
+ t.Errorf("ReadResponse: msg=%q, want %q", msg, wantMsg)
+ }
+ if err.Error() != "550 "+wantMsg {
+ t.Errorf("ReadResponse: error=%q, want %q", err.Error(), "550 "+wantMsg)
+ }
+}
+
func TestCommonHeaders(t *testing.T) {
for h := range commonHeader {
if h != CanonicalMIMEHeaderKey(h) {
diff --git a/src/os/file_plan9.go b/src/os/file_plan9.go
index 085ebc4..c83fa02 100644
--- a/src/os/file_plan9.go
+++ b/src/os/file_plan9.go
@@ -339,7 +339,9 @@
// If newname still contains slashes after removing the oldname
// prefix, the rename is cross-directory and must be rejected.
- // This case is caught by d.Marshal below.
+ if lastIndex(newname, '/') >= 0 {
+ return &LinkError{"rename", oldname, newname, ErrInvalid}
+ }
var d syscall.Dir
@@ -351,6 +353,13 @@
if err != nil {
return &LinkError{"rename", oldname, newname, err}
}
+
+ // If newname already exists and is not a directory, rename replaces it.
+ f, err := Stat(dirname + newname)
+ if err == nil && !f.IsDir() {
+ Remove(dirname + newname)
+ }
+
if err = syscall.Wstat(oldname, buf[:n]); err != nil {
return &LinkError{"rename", oldname, newname, err}
}
diff --git a/src/os/file_windows.go b/src/os/file_windows.go
index bda495e..aa8c05c 100644
--- a/src/os/file_windows.go
+++ b/src/os/file_windows.go
@@ -265,8 +265,10 @@
if len(f.readbuf) == 0 {
numBytes := len(b)
// Windows can't read bytes over max of int16.
- if numBytes > 32767 {
- numBytes = 32767
+ // Some versions of Windows can read even less.
+ // See golang.org/issue/13697.
+ if numBytes > 10000 {
+ numBytes = 10000
}
mbytes := make([]byte, numBytes)
var nmb uint32
@@ -279,10 +281,7 @@
if len(b) > 0 {
pmb = &mbytes[0]
}
- acp, err := windows.GetACP()
- if err != nil {
- return 0, err
- }
+ acp := windows.GetACP()
nwc, err := windows.MultiByteToWideChar(acp, 2, pmb, int32(nmb), nil, 0)
if err != nil {
return 0, err
diff --git a/src/os/os_test.go b/src/os/os_test.go
index 5689e77..945724b 100644
--- a/src/os/os_test.go
+++ b/src/os/os_test.go
@@ -773,9 +773,6 @@
}
func TestRenameOverwriteDest(t *testing.T) {
- if runtime.GOOS == "plan9" {
- t.Skip("skipping on plan9")
- }
defer chtmpdir(t)()
from, to := "renamefrom", "renameto"
// Just in case.
diff --git a/src/os/signal/doc.go b/src/os/signal/doc.go
index 955f3ff..80e66cf 100644
--- a/src/os/signal/doc.go
+++ b/src/os/signal/doc.go
@@ -42,17 +42,18 @@
SIGTTOU signal gets the system default behavior (these signals are
used by the shell for job control). The SIGPROF signal is handled
directly by the Go runtime to implement runtime.CPUProfile. Other
-signals are ignored.
+signals will be caught but no action will be taken.
-If the Go program is started with either SIGHUP or SIGINT ignored,
-they will remain ignored. Go always registers a handler for the other
-signals.
+If the Go program is started with either SIGHUP or SIGINT ignored
+(signal handler set to SIG_IGN), they will remain ignored.
If the Go program is started with a non-empty signal mask, that will
generally be honored. However, some signals are explicitly unblocked:
the synchronous signals, SIGILL, SIGTRAP, SIGSTKFLT, SIGCHLD, SIGPROF,
and, on GNU/Linux, signals 32 (SIGCANCEL) and 33 (SIGSETXID)
-(SIGCANCEL and SIGSETXID are used internally by glibc).
+(SIGCANCEL and SIGSETXID are used internally by glibc). Subprocesses
+started by os.Exec, or by the os/exec package, will inherit the
+modified signal mask.
Changing the behavior of signals in Go programs
@@ -65,12 +66,12 @@
SIGQUIT, SIGABRT, and SIGTERM. It also applies to the job control
signals SIGTSTP, SIGTTIN, and SIGTTOU, in which case the system
default behavior does not occur. It also applies to some signals that
-are otherwise ignored: SIGUSR1, SIGUSR2, SIGPIPE, SIGALRM, SIGCHLD,
-SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGWINCH, SIGIO, SIGPWR, SIGSYS,
-SIGINFO, SIGTHR, SIGWAITING, SIGLWP, SIGFREEZE, SIGTHAW, SIGLOST,
-SIGXRES, SIGJVM1, SIGJVM2, and any real time signals used on the
-system. Note that not all of these signals are available on all
-systems.
+otherwise cause no action: SIGUSR1, SIGUSR2, SIGPIPE, SIGALRM,
+SIGCHLD, SIGCONT, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGWINCH,
+SIGIO, SIGPWR, SIGSYS, SIGINFO, SIGTHR, SIGWAITING, SIGLWP, SIGFREEZE,
+SIGTHAW, SIGLOST, SIGXRES, SIGJVM1, SIGJVM2, and any real time signals
+used on the system. Note that not all of these signals are available
+on all systems.
If the program was started with SIGHUP or SIGINT ignored, and Notify
is called for either signal, a signal handler will be installed for
@@ -89,15 +90,24 @@
SIGPIPE
-When a Go program receives an EPIPE error from the kernel while
-writing to file descriptors 1 or 2 (standard output or standard
-error), it will raise a SIGPIPE signal. If the program is not
-currently receiving SIGPIPE via a call to Notify, this will cause the
-program to exit with SIGPIPE. On descriptors other than 1 or 2, the
-write will return the EPIPE error. This means that, by default,
-command line programs will behave like typical Unix command line
-programs, while other programs will not crash with SIGPIPE when
-writing to a closed network connection.
+When a Go program writes to a broken pipe, the kernel will raise a
+SIGPIPE signal.
+
+If the program has not called Notify to receive SIGPIPE signals, then
+the behavior depends on the file descriptor number. A write to a
+broken pipe on file descriptors 1 or 2 (standard output or standard
+error) will cause the program to exit with a SIGPIPE signal. A write
+to a broken pipe on some other file descriptor will take no action on
+the SIGPIPE signal, and the write will fail with an EPIPE error.
+
+If the program has called Notify to receive SIGPIPE signals, the file
+descriptor number does not matter. The SIGPIPE signal will be
+delivered to the Notify channel, and the write will fail with an EPIPE
+error.
+
+This means that, by default, command line programs will behave like
+typical Unix command line programs, while other programs will not
+crash with SIGPIPE when writing to a closed network connection.
Go programs that use cgo or SWIG
@@ -162,7 +172,10 @@
be run as part of an existing non-Go program. The non-Go code may
have already installed signal handlers when the Go code starts (that
may also happen in unusual cases when using cgo or SWIG; in that case,
-the discussion here applies).
+the discussion here applies). For -buildmode=c-archive the Go runtime
+will initialize signals at global constructor time. For
+-buildmode=c-shared the Go runtime will initialize signals when the
+shared library is loaded.
If the Go runtime sees an existing signal handler for the SIGCANCEL or
SIGSETXID signals (which are used only on GNU/Linux), it will turn on
diff --git a/src/regexp/syntax/parse.go b/src/regexp/syntax/parse.go
index c2b92c1..f38bbf6 100644
--- a/src/regexp/syntax/parse.go
+++ b/src/regexp/syntax/parse.go
@@ -470,9 +470,14 @@
}
sub = out
- // Round 2: Factor out common complex prefixes,
- // just the first piece of each concatenation,
- // whatever it is. This is good enough a lot of the time.
+ // Round 2: Factor out common simple prefixes,
+ // just the first piece of each concatenation.
+ // This will be good enough a lot of the time.
+ //
+ // Complex subexpressions (e.g. involving quantifiers)
+ // are not safe to factor because that collapses their
+ // distinct paths through the automaton, which affects
+ // correctness in some cases.
start = 0
out = sub[:0]
var first *Regexp
@@ -485,7 +490,9 @@
var ifirst *Regexp
if i < len(sub) {
ifirst = p.leadingRegexp(sub[i])
- if first != nil && first.Equal(ifirst) {
+ if first != nil && first.Equal(ifirst) &&
+ // first must be a character class OR a fixed repeat of a character class.
+ (isCharClass(first) || (first.Op == OpRepeat && first.Min == first.Max && isCharClass(first.Sub[0]))) {
continue
}
}
diff --git a/src/regexp/syntax/parse_test.go b/src/regexp/syntax/parse_test.go
index 626ceea..5ca54bb 100644
--- a/src/regexp/syntax/parse_test.go
+++ b/src/regexp/syntax/parse_test.go
@@ -172,7 +172,7 @@
// Factoring.
{`abc|abd|aef|bcx|bcy`, `alt{cat{lit{a}alt{cat{lit{b}cc{0x63-0x64}}str{ef}}}cat{str{bc}cc{0x78-0x79}}}`},
- {`ax+y|ax+z|ay+w`, `cat{lit{a}alt{cat{plus{lit{x}}cc{0x79-0x7a}}cat{plus{lit{y}}lit{w}}}}`},
+ {`ax+y|ax+z|ay+w`, `cat{lit{a}alt{cat{plus{lit{x}}lit{y}}cat{plus{lit{x}}lit{z}}cat{plus{lit{y}}lit{w}}}}`},
// Bug fixes.
{`(?:.)`, `dot{}`},
@@ -195,12 +195,13 @@
{`abc|x|abd`, `alt{str{abc}lit{x}str{abd}}`},
{`(?i)abc|ABD`, `cat{strfold{AB}cc{0x43-0x44 0x63-0x64}}`},
{`[ab]c|[ab]d`, `cat{cc{0x61-0x62}cc{0x63-0x64}}`},
- {`(?:xx|yy)c|(?:xx|yy)d`,
- `cat{alt{str{xx}str{yy}}cc{0x63-0x64}}`},
+ {`.c|.d`, `cat{dot{}cc{0x63-0x64}}`},
{`x{2}|x{2}[0-9]`,
`cat{rep{2,2 lit{x}}alt{emp{}cc{0x30-0x39}}}`},
{`x{2}y|x{2}[0-9]y`,
`cat{rep{2,2 lit{x}}alt{lit{y}cat{cc{0x30-0x39}lit{y}}}}`},
+ {`a.*?c|a.*?b`,
+ `cat{lit{a}alt{cat{nstar{dot{}}lit{c}}cat{nstar{dot{}}lit{b}}}}`},
// Valid repetitions.
{`((((((((((x{2}){2}){2}){2}){2}){2}){2}){2}){2}))`, ``},
diff --git a/src/regexp/testdata/re2-search.txt b/src/regexp/testdata/re2-search.txt
index f648e55..4d02e9c 100644
--- a/src/regexp/testdata/re2-search.txt
+++ b/src/regexp/testdata/re2-search.txt
@@ -3665,3 +3665,8 @@
"(?:a\\C*|ba\\C)$"
-;-;-;-
-;1-4;-;1-4
+strings
+"abc"
+regexps
+"a.*?c|a.*?b"
+0-3;0-3;0-3;0-3
diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index c5f0c51..4181859 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -1439,7 +1439,8 @@
TEXT runtime·cmpbody(SB),NOSPLIT,$0-0
MOVL DX, BP
SUBL BX, DX // DX = blen-alen
- CMOVLGT BX, BP // BP = min(alen, blen)
+ JLE 2(PC)
+ MOVL BX, BP // BP = min(alen, blen)
CMPL SI, DI
JEQ allsame
CMPL BP, $4
@@ -1558,7 +1559,8 @@
ADDL DX, DX
MOVL DX, BX
XORL $0x88888eef, DX
- CMOVLMI BX, DX
+ JPL 2(PC)
+ MOVL BX, DX
MOVL DX, m_fastrand(AX)
MOVL DX, ret+0(FP)
RET
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 6ebe0dc..cac032c 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -56,7 +56,7 @@
JNE noavx
MOVL $0, CX
// For XGETBV, OSXSAVE bit is required and sufficient
- BYTE $0x0F; BYTE $0x01; BYTE $0xD0
+ XGETBV
ANDL $6, AX
CMPL AX, $6 // Check for OS support of YMM registers
JNE noavx
@@ -822,10 +822,10 @@
TEXT runtime·cputicks(SB),NOSPLIT,$0-0
CMPB runtime·lfenceBeforeRdtsc(SB), $1
JNE mfence
- BYTE $0x0f; BYTE $0xae; BYTE $0xe8 // LFENCE
+ LFENCE
JMP done
mfence:
- BYTE $0x0f; BYTE $0xae; BYTE $0xf0 // MFENCE
+ MFENCE
done:
RDTSC
SHLQ $32, DX
diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index d8757fd..09fbc95 100644
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -556,7 +556,13 @@
// lots of space, but the linker doesn't know. Hide the call from
// the linker analysis by using an indirect call.
CMP $0, g
- B.NE havem
+ B.EQ needm
+
+ MOVW g_m(g), R8
+ MOVW R8, savedm-4(SP)
+ B havem
+
+needm:
MOVW g, savedm-4(SP) // g is zero, so is m.
MOVW $runtime·needm(SB), R0
BL (R0)
@@ -577,8 +583,6 @@
MOVW R13, (g_sched+gobuf_sp)(R3)
havem:
- MOVW g_m(g), R8
- MOVW R8, savedm-4(SP)
// Now there's a valid m, and we're running on its m->g0.
// Save current m->g0->sched.sp on stack and then set it to SP.
// Save current sp in m->g0->sched.sp in preparation for
diff --git a/src/runtime/asm_arm64.s b/src/runtime/asm_arm64.s
index 732abe1..ab5d5b5 100644
--- a/src/runtime/asm_arm64.s
+++ b/src/runtime/asm_arm64.s
@@ -586,7 +586,13 @@
// lots of space, but the linker doesn't know. Hide the call from
// the linker analysis by using an indirect call.
CMP $0, g
- BNE havem
+ BEQ needm
+
+ MOVD g_m(g), R8
+ MOVD R8, savedm-8(SP)
+ B havem
+
+needm:
MOVD g, savedm-8(SP) // g is zero, so is m.
MOVD $runtime·needm(SB), R0
BL (R0)
@@ -608,8 +614,6 @@
MOVD R0, (g_sched+gobuf_sp)(R3)
havem:
- MOVD g_m(g), R8
- MOVD R8, savedm-8(SP)
// Now there's a valid m, and we're running on its m->g0.
// Save current m->g0->sched.sp on stack and then set it to SP.
// Save current sp in m->g0->sched.sp in preparation for
diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s
index 7d3d7c2..08482fe 100644
--- a/src/runtime/asm_mips64x.s
+++ b/src/runtime/asm_mips64x.s
@@ -486,7 +486,13 @@
// In this case, we're running on the thread stack, so there's
// lots of space, but the linker doesn't know. Hide the call from
// the linker analysis by using an indirect call.
- BNE g, havem
+ BEQ g, needm
+
+ MOVV g_m(g), R3
+ MOVV R3, savedm-8(SP)
+ JMP havem
+
+needm:
MOVV g, savedm-8(SP) // g is zero, so is m.
MOVV $runtime·needm(SB), R4
JAL (R4)
@@ -507,8 +513,6 @@
MOVV R29, (g_sched+gobuf_sp)(R1)
havem:
- MOVV g_m(g), R3
- MOVV R3, savedm-8(SP)
// Now there's a valid m, and we're running on its m->g0.
// Save current m->g0->sched.sp on stack and then set it to SP.
// Save current sp in m->g0->sched.sp in preparation for
diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s
index f3b193a..50c4f26 100644
--- a/src/runtime/asm_ppc64x.s
+++ b/src/runtime/asm_ppc64x.s
@@ -602,7 +602,13 @@
// lots of space, but the linker doesn't know. Hide the call from
// the linker analysis by using an indirect call.
CMP g, $0
- BNE havem
+ BEQ needm
+
+ MOVD g_m(g), R8
+ MOVD R8, savedm-8(SP)
+ BR havem
+
+needm:
MOVD g, savedm-8(SP) // g is zero, so is m.
MOVD $runtime·needm(SB), R12
MOVD R12, CTR
@@ -619,13 +625,11 @@
// and then systemstack will try to use it. If we don't set it here,
// that restored SP will be uninitialized (typically 0) and
// will not be usable.
- MOVD g_m(g), R3
- MOVD m_g0(R3), R3
+ MOVD g_m(g), R8
+ MOVD m_g0(R8), R3
MOVD R1, (g_sched+gobuf_sp)(R3)
havem:
- MOVD g_m(g), R8
- MOVD R8, savedm-8(SP)
// Now there's a valid m, and we're running on its m->g0.
// Save current m->g0->sched.sp on stack and then set it to SP.
// Save current sp in m->g0->sched.sp in preparation for
diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 17799fc..210d186 100644
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -354,7 +354,7 @@
t := ep._type
top := true
- if len(args) > 0 && t.kind&kindMask == kindPtr {
+ if len(args) > 0 && (t.kind&kindMask == kindPtr || t.kind&kindMask == kindUnsafePointer) {
p := ep.data
if t.kind&kindDirectIface == 0 {
p = *(*unsafe.Pointer)(p)
@@ -365,6 +365,10 @@
aep := (*eface)(unsafe.Pointer(&args[0]))
switch aep._type.kind & kindMask {
case kindBool:
+ if t.kind&kindMask == kindUnsafePointer {
+ // We don't know the type of the element.
+ break
+ }
pt := (*ptrtype)(unsafe.Pointer(t))
cgoCheckArg(pt.elem, p, true, false, cgoCheckPointerFail)
return ptr
@@ -494,22 +498,26 @@
// cgoCheckUnknownPointer is called for an arbitrary pointer into Go
// memory. It checks whether that Go memory contains any other
// pointer into Go memory. If it does, we panic.
-func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) {
+// The return values are unused but useful to see in panic tracebacks.
+func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
if cgoInRange(p, mheap_.arena_start, mheap_.arena_used) {
if !inheap(uintptr(p)) {
- // This pointer is either to a stack or to an
- // unused span. Escape analysis should
- // prevent the former and the latter should
- // not happen.
- panic(errorString("cgo argument has invalid Go pointer"))
+ // On 32-bit systems it is possible for C's allocated memory
+ // to have addresses between arena_start and arena_used.
+ // Either this pointer is a stack or an unused span or it's
+ // a C allocation. Escape analysis should prevent the first,
+ // garbage collection should prevent the second,
+ // and the third is completely OK.
+ return
}
- base, hbits, span := heapBitsForObject(uintptr(p), 0, 0)
+ b, hbits, span := heapBitsForObject(uintptr(p), 0, 0)
+ base = b
if base == 0 {
return
}
n := span.elemsize
- for i := uintptr(0); i < n; i += sys.PtrSize {
+ for i = uintptr(0); i < n; i += sys.PtrSize {
bits := hbits.bits()
if i >= 2*sys.PtrSize && bits&bitMarked == 0 {
// No more possible pointers.
@@ -535,6 +543,8 @@
// In the text or noptr sections, we know that the
// pointer does not point to a Go pointer.
}
+
+ return
}
// cgoIsGoPointer returns whether the pointer is a Go pointer--a
diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go
index 9422a08..d7b367f 100644
--- a/src/runtime/crash_cgo_test.go
+++ b/src/runtime/crash_cgo_test.go
@@ -134,3 +134,16 @@
t.Errorf("expected %q, got %v", want, got)
}
}
+
+func TestEnsureDropM(t *testing.T) {
+ // Test for issue 13881.
+ switch runtime.GOOS {
+ case "windows", "plan9":
+ t.Skipf("skipping dropm test on %s", runtime.GOOS)
+ }
+ got := runTestProg(t, "testprogcgo", "EnsureDropM")
+ want := "OK\n"
+ if got != want {
+ t.Errorf("expected %q, got %v", want, got)
+ }
+}
diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go
index 4756e1a..b622eb4 100644
--- a/src/runtime/crash_test.go
+++ b/src/runtime/crash_test.go
@@ -99,7 +99,7 @@
exe = ""
target.err = fmt.Errorf("building %s: %v\n%s", binary, err, out)
testprog.target[binary] = target
- return "", err
+ return "", target.err
}
target.exe = exe
testprog.target[binary] = target
diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index 5942527..a7af7ef 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -151,3 +151,11 @@
t.Errorf("got %v; expected SIGTERM", ee)
}
}
+
+func TestSignalIgnoreSIGTRAP(t *testing.T) {
+ output := runTestProg(t, "testprognet", "SignalIgnoreSIGTRAP")
+ want := "OK\n"
+ if output != want {
+ t.Fatalf("want %s, got %s\n", want, output)
+ }
+}
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index 6a4eae6..5400c1d 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -163,3 +163,11 @@
var TestingAssertE2T2GC = &testingAssertE2T2GC
var ForceGCPeriod = &forcegcperiod
+
+// SetTracebackEnv is like runtime/debug.SetTraceback, but it raises
+// the "environment" traceback level, so later calls to
+// debug.SetTraceback (e.g., from testing timeouts) can't lower it.
+func SetTracebackEnv(level string) {
+ setTraceback(level)
+ traceback_env = traceback_cache
+}
diff --git a/src/runtime/extern.go b/src/runtime/extern.go
index cab8de0..2c98482 100644
--- a/src/runtime/extern.go
+++ b/src/runtime/extern.go
@@ -66,7 +66,7 @@
length of the pause. Setting gctrace=2 emits the same summary but also
repeats each collection. The format of this line is subject to change.
Currently, it is:
- gc # @#s #%: #+...+# ms clock, #+...+# ms cpu, #->#-># MB, # MB goal, # P
+ gc # @#s #%: #+#+# ms clock, #+#/#/#+# ms cpu, #->#-># MB, # MB goal, # P
where the fields are as follows:
gc # the GC number, incremented at each GC
@#s time in seconds since program start
@@ -75,9 +75,9 @@
#->#-># MB heap size at GC start, at GC end, and live heap
# MB goal goal heap size
# P number of processors used
- The phases are stop-the-world (STW) sweep termination, scan,
- synchronize Ps, mark, and STW mark termination. The CPU times
- for mark are broken down in to assist time (GC performed in
+ The phases are stop-the-world (STW) sweep termination, concurrent
+ mark and scan, and STW mark termination. The CPU times
+ for mark/scan are broken down in to assist time (GC performed in
line with allocation), background GC time, and idle GC time.
If the line ends with "(forced)", this GC was forced by a
runtime.GC() call and all phases are STW.
@@ -105,6 +105,9 @@
schedtrace: setting schedtrace=X causes the scheduler to emit a single line to standard
error every X milliseconds, summarizing the scheduler state.
+The net and net/http packages also refer to debugging variables in GODEBUG.
+See the documentation for those packages for details.
+
The GOMAXPROCS variable limits the number of operating system threads that
can execute user-level Go code simultaneously. There is no limit to the number of threads
that can be blocked in system calls on behalf of Go code; those do not count against
diff --git a/src/runtime/futex_test.go b/src/runtime/futex_test.go
index b85249a..8504396 100644
--- a/src/runtime/futex_test.go
+++ b/src/runtime/futex_test.go
@@ -13,6 +13,8 @@
import (
"runtime"
+ "sync"
+ "sync/atomic"
"testing"
"time"
)
@@ -21,12 +23,12 @@
mtx uint32
ns int64
msg string
- ch chan futexsleepTest
+ ch chan *futexsleepTest
}
var futexsleepTests = []futexsleepTest{
- beforeY2038: {mtx: 0, ns: 86400 * 1e9, msg: "before the year 2038", ch: make(chan futexsleepTest, 1)},
- afterY2038: {mtx: 0, ns: (1<<31 + 100) * 1e9, msg: "after the year 2038", ch: make(chan futexsleepTest, 1)},
+ beforeY2038: {mtx: 0, ns: 86400 * 1e9, msg: "before the year 2038"},
+ afterY2038: {mtx: 0, ns: (1<<31 + 100) * 1e9, msg: "after the year 2038"},
}
const (
@@ -42,12 +44,18 @@
}
start := time.Now()
- for _, tt := range futexsleepTests {
- go func(tt futexsleepTest) {
+ var wg sync.WaitGroup
+ for i := range futexsleepTests {
+ tt := &futexsleepTests[i]
+ tt.mtx = 0
+ tt.ch = make(chan *futexsleepTest, 1)
+ wg.Add(1)
+ go func(tt *futexsleepTest) {
runtime.Entersyscall(0)
- runtime.Futexsleep(&tt.mtx, tt.mtx, tt.ns)
+ runtime.Futexsleep(&tt.mtx, 0, tt.ns)
runtime.Exitsyscall(0)
tt.ch <- tt
+ wg.Done()
}(tt)
}
loop:
@@ -71,7 +79,10 @@
break loop
}
}
- for _, tt := range futexsleepTests {
+ for i := range futexsleepTests {
+ tt := &futexsleepTests[i]
+ atomic.StoreUint32(&tt.mtx, 1)
runtime.Futexwakeup(&tt.mtx, 1)
}
+ wg.Wait()
}
diff --git a/src/runtime/internal/atomic/atomic_386.go b/src/runtime/internal/atomic/atomic_386.go
index ae7b583..f4c50b0 100644
--- a/src/runtime/internal/atomic/atomic_386.go
+++ b/src/runtime/internal/atomic/atomic_386.go
@@ -8,19 +8,15 @@
import "unsafe"
-// The calls to nop are to keep these functions from being inlined.
-// If they are inlined we have no guarantee that later rewrites of the
-// code by optimizers will preserve the relative order of memory accesses.
-
//go:nosplit
+//go:noinline
func Load(ptr *uint32) uint32 {
- nop()
return *ptr
}
//go:nosplit
+//go:noinline
func Loadp(ptr unsafe.Pointer) unsafe.Pointer {
- nop()
return *(*unsafe.Pointer)(ptr)
}
diff --git a/src/runtime/internal/atomic/atomic_amd64x.go b/src/runtime/internal/atomic/atomic_amd64x.go
index 7f6c892..bd40fb3 100644
--- a/src/runtime/internal/atomic/atomic_amd64x.go
+++ b/src/runtime/internal/atomic/atomic_amd64x.go
@@ -8,25 +8,21 @@
import "unsafe"
-// The calls to nop are to keep these functions from being inlined.
-// If they are inlined we have no guarantee that later rewrites of the
-// code by optimizers will preserve the relative order of memory accesses.
-
//go:nosplit
+//go:noinline
func Load(ptr *uint32) uint32 {
- nop()
return *ptr
}
//go:nosplit
+//go:noinline
func Loadp(ptr unsafe.Pointer) unsafe.Pointer {
- nop()
return *(*unsafe.Pointer)(ptr)
}
//go:nosplit
+//go:noinline
func Load64(ptr *uint64) uint64 {
- nop()
return *ptr
}
diff --git a/src/runtime/internal/atomic/stubs.go b/src/runtime/internal/atomic/stubs.go
index 8268299..497b980 100644
--- a/src/runtime/internal/atomic/stubs.go
+++ b/src/runtime/internal/atomic/stubs.go
@@ -12,8 +12,6 @@
// NO go:noescape annotation; see atomic_pointer.go.
func Casp1(ptr *unsafe.Pointer, old, new unsafe.Pointer) bool
-func nop() // call to prevent inlining of function body
-
//go:noescape
func Casuintptr(ptr *uintptr, old, new uintptr) bool
diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index d4487ee..18001bf 100644
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -455,7 +455,7 @@
}
if p < h.arena_start || uintptr(p)+p_size-h.arena_start >= _MaxArena32 {
- print("runtime: memory allocated by OS (", p, ") not in usable range [", hex(h.arena_start), ",", hex(h.arena_start+_MaxArena32), ")\n")
+ print("runtime: memory allocated by OS (", hex(p), ") not in usable range [", hex(h.arena_start), ",", hex(h.arena_start+_MaxArena32), ")\n")
sysFree(unsafe.Pointer(p), p_size, &memstats.heap_sys)
return nil
}
diff --git a/src/runtime/mbitmap.go b/src/runtime/mbitmap.go
index 03435a5..336d4d8 100644
--- a/src/runtime/mbitmap.go
+++ b/src/runtime/mbitmap.go
@@ -333,7 +333,7 @@
return true
}
// Otherwise, at least a 2-word object, and at least 2-word aligned,
- // so h.shift is either 0 or 4, so we know we can get the bits for the
+ // so h.shift is either 0 or 2, so we know we can get the bits for the
// first two words out of *h.bitp.
// If either of the first two words is a pointer, not pointer free.
b := uint32(*h.bitp >> h.shift)
diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 01b72ee..92b8118 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -1121,6 +1121,10 @@
// finalizers have been scanned.
work.finalizersDone = true
+ // Disable assists and background workers. We must do
+ // this before waking blocked assists.
+ atomic.Store(&gcBlackenEnabled, 0)
+
// Flush the gcWork caches. This must be done before
// endCycle since endCycle depends on statistics kept
// in these caches.
@@ -1263,23 +1267,13 @@
if debug.gctrace > 0 {
util := int(memstats.gc_cpu_fraction * 100)
- // Install WB phase is no longer used.
- tInstallWB := work.tMark
- installWBCpu := int64(0)
-
- // Scan phase is no longer used.
- tScan := tInstallWB
- scanCpu := int64(0)
-
- // TODO: Clean up the gctrace format.
-
var sbuf [24]byte
printlock()
print("gc ", memstats.numgc,
" @", string(itoaDiv(sbuf[:], uint64(work.tSweepTerm-runtimeInitTime)/1e6, 3)), "s ",
util, "%: ")
prev := work.tSweepTerm
- for i, ns := range []int64{tScan, tInstallWB, work.tMark, work.tMarkTerm, work.tEnd} {
+ for i, ns := range []int64{work.tMark, work.tMarkTerm, work.tEnd} {
if i != 0 {
print("+")
}
@@ -1287,8 +1281,8 @@
prev = ns
}
print(" ms clock, ")
- for i, ns := range []int64{sweepTermCpu, scanCpu, installWBCpu, gcController.assistTime, gcController.dedicatedMarkTime + gcController.fractionalMarkTime, gcController.idleMarkTime, markTermCpu} {
- if i == 4 || i == 5 {
+ for i, ns := range []int64{sweepTermCpu, gcController.assistTime, gcController.dedicatedMarkTime + gcController.fractionalMarkTime, gcController.idleMarkTime, markTermCpu} {
+ if i == 2 || i == 3 {
// Separate mark time components with /.
print("/")
} else if i != 0 {
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index e9f673a..eac45ec 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -491,7 +491,8 @@
}
// gcWakeAllAssists wakes all currently blocked assists. This is used
-// at the end of a GC cycle.
+// at the end of a GC cycle. gcBlackenEnabled must be false to prevent
+// new assists from going to sleep after this point.
func gcWakeAllAssists() {
lock(&work.assistQueue.lock)
injectglist(work.assistQueue.head.ptr())
@@ -796,7 +797,7 @@
}
gp := getg()
- preemtible := flags&gcDrainUntilPreempt != 0
+ preemptible := flags&gcDrainUntilPreempt != 0
blocking := flags&(gcDrainUntilPreempt|gcDrainNoBlock) == 0
flushBgCredit := flags&gcDrainFlushBgCredit != 0
@@ -815,9 +816,13 @@
initScanWork := gcw.scanWork
// Drain heap marking jobs.
- for !(preemtible && gp.preempt) {
- // If another proc wants a pointer, give it some.
- if work.nwait > 0 && work.full == 0 {
+ for !(preemptible && gp.preempt) {
+ // Try to keep work available on the global queue. We used to
+ // check if there were waiting workers, but it's better to
+ // just keep work available than to make workers wait. In the
+ // worst case, we'll do O(log(_WorkbufSize)) unnecessary
+ // balances.
+ if work.full == 0 {
gcw.balance()
}
@@ -831,12 +836,6 @@
// work barrier reached or tryGet failed.
break
}
- // If the current wbuf is filled by the scan a new wbuf might be
- // returned that could possibly hold only a single object. This
- // could result in each iteration draining only a single object
- // out of the wbuf passed in + a single object placed
- // into an empty wbuf in scanobject so there could be
- // a performance hit as we keep fetching fresh wbufs.
scanobject(b, gcw)
// Flush background scan work credit to the global
@@ -884,10 +883,16 @@
gp := getg().m.curg
for !gp.preempt && workFlushed+gcw.scanWork < scanWork {
+ // See gcDrain comment.
+ if work.full == 0 {
+ gcw.balance()
+ }
+
// This might be a good place to add prefetch code...
// if(wbuf.nobj > 4) {
// PREFETCH(wbuf->obj[wbuf.nobj - 3];
// }
+ //
b := gcw.tryGet()
if b == 0 {
break
@@ -1032,7 +1037,7 @@
// obj is the start of an object with mark mbits.
// If it isn't already marked, mark it and enqueue into gcw.
// base and off are for debugging only and could be removed.
-//go:nowritebarrier
+//go:nowritebarrierrec
func greyobject(obj, base, off uintptr, hbits heapBits, span *mspan, gcw *gcWork) {
// obj should be start of allocation, and so must be at least pointer-aligned.
if obj&(sys.PtrSize-1) != 0 {
diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index 684ab0b..eb7231a 100644
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -576,12 +576,17 @@
pc := getcallerpc(unsafe.Pointer(&buf))
systemstack(func() {
g0 := getg()
+ // Force traceback=1 to override GOTRACEBACK setting,
+ // so that Stack's results are consistent.
+ // GOTRACEBACK is only about crash dumps.
+ g0.m.traceback = 1
g0.writebuf = buf[0:0:len(buf)]
goroutineheader(gp)
traceback(pc, sp, 0, gp)
if all {
tracebackothers(gp)
}
+ g0.m.traceback = 0
n = len(g0.writebuf)
g0.writebuf = nil
})
diff --git a/src/runtime/os1_darwin.go b/src/runtime/os1_darwin.go
index d34af6b..e9e0b6a 100644
--- a/src/runtime/os1_darwin.go
+++ b/src/runtime/os1_darwin.go
@@ -125,6 +125,15 @@
var failallocatestack = []byte("runtime: failed to allocate stack for the new OS thread\n")
var failthreadcreate = []byte("runtime: failed to create new OS thread\n")
+// Called to do synchronous initialization of Go code built with
+// -buildmode=c-archive or -buildmode=c-shared.
+// None of the Go runtime is initialized.
+//go:nosplit
+//go:nowritebarrierrec
+func libpreinit() {
+ initsig(true)
+}
+
// Called to initialize a new m (including the bootstrap m).
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
func mpreinit(mp *m) {
@@ -138,8 +147,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, &mp.sigmask, nil)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, &sigmask, nil)
}
//go:nosplit
@@ -459,6 +468,8 @@
return 0
}
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
@@ -471,6 +482,8 @@
sigaction(uint32(i), &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
var osa usigactiont
sigaction(uint32(i), nil, &osa)
@@ -486,6 +499,8 @@
sigaction(uint32(i), &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa usigactiont
sigaction(uint32(i), nil, &sa)
@@ -505,6 +520,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
s := sigset(m[0])
sigprocmask(_SIG_SETMASK, &s, nil)
diff --git a/src/runtime/os1_dragonfly.go b/src/runtime/os1_dragonfly.go
index 5f0f00c..a739ef5 100644
--- a/src/runtime/os1_dragonfly.go
+++ b/src/runtime/os1_dragonfly.go
@@ -123,8 +123,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, &mp.sigmask, nil)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, &sigmask, nil)
}
//go:nosplit
@@ -168,6 +168,7 @@
}
// Called from dropm to undo the effect of an minit.
+//go:nosplit
func unminit() {
if getg().m.newSigstack {
signalstack(nil)
@@ -213,6 +214,8 @@
sa_mask sigset
}
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
@@ -227,10 +230,14 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
throw("setsigstack")
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -253,6 +260,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
var mask sigset
copy(mask.__bits[:], m[:])
diff --git a/src/runtime/os1_freebsd.go b/src/runtime/os1_freebsd.go
index 52e8dcb..79d9954 100644
--- a/src/runtime/os1_freebsd.go
+++ b/src/runtime/os1_freebsd.go
@@ -126,8 +126,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, &mp.sigmask, nil)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, &sigmask, nil)
}
//go:nosplit
@@ -220,6 +220,8 @@
sa_mask sigset
}
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
@@ -234,10 +236,14 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
throw("setsigstack")
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -260,6 +266,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m [(_NSIG + 31) / 32]uint32) {
var mask sigset
copy(mask.__bits[:], m[:])
diff --git a/src/runtime/os1_linux.go b/src/runtime/os1_linux.go
index 961fadd..b38cfc1 100644
--- a/src/runtime/os1_linux.go
+++ b/src/runtime/os1_linux.go
@@ -190,6 +190,15 @@
goenvs_unix()
}
+// Called to do synchronous initialization of Go code built with
+// -buildmode=c-archive or -buildmode=c-shared.
+// None of the Go runtime is initialized.
+//go:nosplit
+//go:nowritebarrierrec
+func libpreinit() {
+ initsig(true)
+}
+
// Called to initialize a new m (including the bootstrap m).
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
func mpreinit(mp *m) {
@@ -204,9 +213,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- smask := &mp.sigmask
- rtsigprocmask(_SIG_SETMASK, smask, nil, int32(unsafe.Sizeof(*smask)))
+func msigrestore(sigmask sigset) {
+ rtsigprocmask(_SIG_SETMASK, &sigmask, nil, int32(unsafe.Sizeof(sigmask)))
}
//go:nosplit
@@ -298,6 +306,8 @@
func sigreturn()
func sigtramp()
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
memclr(unsafe.Pointer(&sa), unsafe.Sizeof(sa))
@@ -316,12 +326,11 @@
fn = funcPC(sigtramp)
}
sa.sa_handler = fn
- // Qemu rejects rt_sigaction of SIGRTMAX (64).
- if rt_sigaction(uintptr(i), &sa, nil, unsafe.Sizeof(sa.sa_mask)) != 0 && i != 64 {
- throw("rt_sigaction failure")
- }
+ rt_sigaction(uintptr(i), &sa, nil, unsafe.Sizeof(sa.sa_mask))
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
var sa sigactiont
if rt_sigaction(uintptr(i), nil, &sa, unsafe.Sizeof(sa.sa_mask)) != 0 {
@@ -336,6 +345,8 @@
}
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
@@ -362,6 +373,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
var mask sigset
sigcopyset(&mask, m)
diff --git a/src/runtime/os1_nacl.go b/src/runtime/os1_nacl.go
index c721261..dab205d 100644
--- a/src/runtime/os1_nacl.go
+++ b/src/runtime/os1_nacl.go
@@ -22,7 +22,7 @@
}
//go:nosplit
-func msigrestore(mp *m) {
+func msigrestore(sigmask sigset) {
}
//go:nosplit
@@ -67,7 +67,7 @@
goenvs_unix()
}
-func initsig() {
+func initsig(preinit bool) {
}
//go:nosplit
diff --git a/src/runtime/os1_netbsd.go b/src/runtime/os1_netbsd.go
index 2849b5a..4219902 100644
--- a/src/runtime/os1_netbsd.go
+++ b/src/runtime/os1_netbsd.go
@@ -144,8 +144,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, &mp.sigmask, nil)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, &sigmask, nil)
}
//go:nosplit
@@ -206,6 +206,8 @@
sa_flags int32
}
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
@@ -220,10 +222,14 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
throw("setsigstack")
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -246,6 +252,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
var mask sigset
copy(mask.__bits[:], m[:])
diff --git a/src/runtime/os1_openbsd.go b/src/runtime/os1_openbsd.go
index 24d8477..a6cefa2 100644
--- a/src/runtime/os1_openbsd.go
+++ b/src/runtime/os1_openbsd.go
@@ -156,8 +156,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, mp.sigmask)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, sigmask)
}
//go:nosplit
@@ -220,6 +220,8 @@
sa_flags int32
}
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
@@ -234,10 +236,14 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
throw("setsigstack")
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -260,6 +266,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
sigprocmask(_SIG_SETMASK, sigset(m[0]))
}
diff --git a/src/runtime/os1_plan9.go b/src/runtime/os1_plan9.go
index a75e956..7506d59 100644
--- a/src/runtime/os1_plan9.go
+++ b/src/runtime/os1_plan9.go
@@ -26,7 +26,7 @@
func msigsave(mp *m) {
}
-func msigrestore(mp *m) {
+func msigrestore(sigmask sigset) {
}
func sigblock() {
@@ -107,7 +107,7 @@
func goenvs() {
}
-func initsig() {
+func initsig(preinit bool) {
}
//go:nosplit
diff --git a/src/runtime/os1_windows.go b/src/runtime/os1_windows.go
index a59e9ec..a28e11e 100644
--- a/src/runtime/os1_windows.go
+++ b/src/runtime/os1_windows.go
@@ -391,7 +391,7 @@
}
//go:nosplit
-func msigrestore(mp *m) {
+func msigrestore(sigmask sigset) {
}
//go:nosplit
diff --git a/src/runtime/os2_dragonfly.go b/src/runtime/os2_dragonfly.go
index ccad82f..6ea2da0 100644
--- a/src/runtime/os2_dragonfly.go
+++ b/src/runtime/os2_dragonfly.go
@@ -6,7 +6,7 @@
const (
_NSIG = 33
- _SI_USER = 0x10001
+ _SI_USER = 0
_SS_DISABLE = 4
_RLIMIT_AS = 10
_SIG_BLOCK = 1
diff --git a/src/runtime/os3_solaris.go b/src/runtime/os3_solaris.go
index 940a841..7bda07b 100644
--- a/src/runtime/os3_solaris.go
+++ b/src/runtime/os3_solaris.go
@@ -198,8 +198,8 @@
}
//go:nosplit
-func msigrestore(mp *m) {
- sigprocmask(_SIG_SETMASK, &mp.sigmask, nil)
+func msigrestore(sigmask sigset) {
+ sigprocmask(_SIG_SETMASK, &sigmask, nil)
}
//go:nosplit
@@ -279,6 +279,8 @@
func sigtramp()
+//go:nosplit
+//go:nowritebarrierrec
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
@@ -295,6 +297,8 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func setsigstack(i int32) {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -306,6 +310,8 @@
sigaction(i, &sa, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
@@ -328,6 +334,8 @@
sigaltstack(&st, nil)
}
+//go:nosplit
+//go:nowritebarrierrec
func updatesigmask(m sigmask) {
var mask sigset
copy(mask.__sigbits[:], m[:])
@@ -478,6 +486,8 @@
return int32(sysvicall4(&libc_pthread_create, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(fn), uintptr(arg)))
}
+//go:nosplit
+//go:nowritebarrierrec
func raise(sig int32) /* int32 */ {
sysvicall1(&libc_raise, uintptr(sig))
}
@@ -516,15 +526,20 @@
sysvicall3(&libc_setitimer, uintptr(which), uintptr(unsafe.Pointer(value)), uintptr(unsafe.Pointer(ovalue)))
}
+//go:nosplit
+//go:nowritebarrierrec
func sigaction(sig int32, act *sigactiont, oact *sigactiont) /* int32 */ {
sysvicall3(&libc_sigaction, uintptr(sig), uintptr(unsafe.Pointer(act)), uintptr(unsafe.Pointer(oact)))
}
+//go:nosplit
+//go:nowritebarrierrec
func sigaltstack(ss *sigaltstackt, oss *sigaltstackt) /* int32 */ {
sysvicall2(&libc_sigaltstack, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(oss)))
}
//go:nosplit
+//go:nowritebarrierrec
func sigprocmask(how int32, set *sigset, oset *sigset) /* int32 */ {
sysvicall3(&libc_sigprocmask, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oset)))
}
diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index db6e82d..24bf945 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -333,11 +333,11 @@
}
func TestStackBarrierProfiling(t *testing.T) {
- if (runtime.GOOS == "linux" && runtime.GOARCH == "arm") || runtime.GOOS == "openbsd" || runtime.GOOS == "solaris" || runtime.GOOS == "dragonfly" {
+ if (runtime.GOOS == "linux" && runtime.GOARCH == "arm") || runtime.GOOS == "openbsd" || runtime.GOOS == "solaris" || runtime.GOOS == "dragonfly" || runtime.GOOS == "freebsd" {
// This test currently triggers a large number of
// usleep(100)s. These kernels/arches have poor
// resolution timers, so this gives up a whole
- // scheduling quantum. On Linux and OpenBSD (and
+ // scheduling quantum. On Linux and the BSDs (and
// probably Solaris), profiling signals are only
// generated when a process completes a whole
// scheduling quantum, so this test often gets zero
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index fd8e161..a7e94a9 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1088,7 +1088,7 @@
cgoHasExtraM = true
newextram()
}
- initsig()
+ initsig(false)
}
if fn := _g_.m.mstartfn; fn != nil {
@@ -1427,20 +1427,29 @@
// After the call to setg we can only call nosplit functions
// with no pointer manipulation.
mp := getg().m
- mnext := lockextra(true)
- mp.schedlink.set(mnext)
// Block signals before unminit.
// Unminit unregisters the signal handling stack (but needs g on some systems).
// Setg(nil) clears g, which is the signal handler's cue not to run Go handlers.
// It's important not to try to handle a signal between those two steps.
+ sigmask := mp.sigmask
sigblock()
unminit()
+
+ mnext := lockextra(true)
+ mp.schedlink.set(mnext)
+
setg(nil)
- msigrestore(mp)
// Commit the release of mp.
unlockextra(mp)
+
+ msigrestore(sigmask)
+}
+
+// A helper function for EnsureDropM.
+func getm() uintptr {
+ return uintptr(unsafe.Pointer(getg().m))
}
var extram uintptr
@@ -2162,6 +2171,9 @@
_g_ := getg()
casgstatus(gp, _Grunning, _Gdead)
+ if isSystemGoroutine(gp) {
+ atomic.Xadd(&sched.ngsys, -1)
+ }
gp.m = nil
gp.lockedm = nil
_g_.m.lockedg = nil
@@ -2693,6 +2705,9 @@
gostartcallfn(&newg.sched, fn)
newg.gopc = callerpc
newg.startpc = fn.fn
+ if isSystemGoroutine(newg) {
+ atomic.Xadd(&sched.ngsys, +1)
+ }
casgstatus(newg, _Gdead, _Grunnable)
if _p_.goidcache == _p_.goidcacheend {
@@ -2885,7 +2900,7 @@
}
func gcount() int32 {
- n := int32(allglen) - sched.ngfree
+ n := int32(allglen) - sched.ngfree - int32(atomic.Load(&sched.ngsys))
for i := 0; ; i++ {
_p_ := allp[i]
if _p_ == nil {
@@ -2989,49 +3004,50 @@
// To recap, there are no constraints on the assembly being used for the
// transition. We simply require that g and SP match and that the PC is not
// in gogo.
- traceback, tracebackUser := true, true
- haveStackLock := false
+ traceback := true
if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) {
traceback = false
- } else if gp.m.curg != nil {
- // The user stack is safe to scan only if we can
- // acquire the stack barrier lock.
- if gcTryLockStackBarriers(gp.m.curg) {
- haveStackLock = true
- } else {
- // Stack barriers are being inserted or
- // removed, so we can't get a consistent
- // traceback of the user stack right now.
- tracebackUser = false
- if gp == gp.m.curg {
- // We're on the user stack, so don't
- // do any traceback.
- traceback = false
- }
- }
}
var stk [maxCPUProfStack]uintptr
+ var haveStackLock *g
n := 0
- if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 && tracebackUser {
+ if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
// Cgo, we can't unwind and symbolize arbitrary C code,
// so instead collect Go stack that leads to the cgo call.
// This is especially important on windows, since all syscalls are cgo calls.
- n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[0], len(stk), nil, nil, 0)
+ if gcTryLockStackBarriers(mp.curg) {
+ haveStackLock = mp.curg
+ n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[0], len(stk), nil, nil, 0)
+ }
} else if traceback {
var flags uint = _TraceTrap
- if tracebackUser {
+ if gp.m.curg != nil && gcTryLockStackBarriers(gp.m.curg) {
+ // It's safe to traceback the user stack.
+ haveStackLock = gp.m.curg
flags |= _TraceJumpStack
}
- n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, flags)
+ // Traceback is safe if we're on the system stack (if
+ // necessary, flags will stop it before switching to
+ // the user stack), or if we locked the user stack.
+ if gp != gp.m.curg || haveStackLock != nil {
+ n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, flags)
+ }
}
- if !traceback || n <= 0 {
+ if haveStackLock != nil {
+ gcUnlockStackBarriers(haveStackLock)
+ }
+
+ if n <= 0 {
// Normal traceback is impossible or has failed.
// See if it falls into several common cases.
n = 0
- if GOOS == "windows" && n == 0 && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 && tracebackUser {
+ if GOOS == "windows" && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 {
// Libcall, i.e. runtime syscall on windows.
// Collect Go stack that leads to the call.
- n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0)
+ if gcTryLockStackBarriers(mp.libcallg.ptr()) {
+ n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0)
+ gcUnlockStackBarriers(mp.libcallg.ptr())
+ }
}
if n == 0 {
// If all of the above has failed, account it against abstract "System" or "GC".
@@ -3048,9 +3064,6 @@
}
}
}
- if haveStackLock {
- gcUnlockStackBarriers(gp.m.curg)
- }
if prof.hz != 0 {
// Simple cas-lock to coordinate with setcpuprofilerate.
diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go
index 30798f7..f3e90bc 100644
--- a/src/runtime/proc_test.go
+++ b/src/runtime/proc_test.go
@@ -9,6 +9,7 @@
"net"
"runtime"
"runtime/debug"
+ "strings"
"sync"
"sync/atomic"
"syscall"
@@ -336,6 +337,23 @@
}
}
+func TestNumGoroutine(t *testing.T) {
+ output := runTestProg(t, "testprog", "NumGoroutine")
+ want := "1\n"
+ if output != want {
+ t.Fatalf("want %q, got %q", want, output)
+ }
+
+ buf := make([]byte, 1<<20)
+ buf = buf[:runtime.Stack(buf, true)]
+
+ n := runtime.NumGoroutine()
+
+ if nstk := strings.Count(string(buf), "goroutine "); n != nstk {
+ t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump", n, nstk)
+ }
+}
+
func TestPingPongHog(t *testing.T) {
if testing.Short() {
t.Skip("skipping in -short mode")
diff --git a/src/runtime/rt0_darwin_386.s b/src/runtime/rt0_darwin_386.s
index be2e564..6b404db 100644
--- a/src/runtime/rt0_darwin_386.s
+++ b/src/runtime/rt0_darwin_386.s
@@ -25,6 +25,10 @@
MOVL 12(BP), AX
MOVL AX, _rt0_386_darwin_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVL $runtime·libpreinit(SB), AX
+ CALL AX
+
SUBL $12, SP
// Create a new thread to do the runtime initialization and return.
diff --git a/src/runtime/rt0_darwin_amd64.s b/src/runtime/rt0_darwin_amd64.s
index 8d50e96..ad46fd4 100644
--- a/src/runtime/rt0_darwin_amd64.s
+++ b/src/runtime/rt0_darwin_amd64.s
@@ -12,10 +12,21 @@
// When linking with -shared, this symbol is called when the shared library
// is loaded.
-TEXT _rt0_amd64_darwin_lib(SB),NOSPLIT,$40
+TEXT _rt0_amd64_darwin_lib(SB),NOSPLIT,$0x48
+ MOVQ BX, 0x18(SP)
+ MOVQ BP, 0x20(SP)
+ MOVQ R12, 0x28(SP)
+ MOVQ R13, 0x30(SP)
+ MOVQ R14, 0x38(SP)
+ MOVQ R15, 0x40(SP)
+
MOVQ DI, _rt0_amd64_darwin_lib_argc<>(SB)
MOVQ SI, _rt0_amd64_darwin_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVQ $runtime·libpreinit(SB), AX
+ CALL AX
+
// Create a new thread to do the runtime initialization and return.
MOVQ _cgo_sys_thread_create(SB), AX
TESTQ AX, AX
@@ -23,7 +34,8 @@
MOVQ $_rt0_amd64_darwin_lib_go(SB), DI
MOVQ $0, SI
CALL AX
- RET
+ JMP restore
+
nocgo:
MOVQ $8388608, 0(SP) // stacksize
MOVQ $_rt0_amd64_darwin_lib_go(SB), AX
@@ -31,6 +43,14 @@
MOVQ $0, 16(SP) // fnarg
MOVQ $runtime·newosproc0(SB), AX
CALL AX
+
+restore:
+ MOVQ 0x18(SP), BX
+ MOVQ 0x20(SP), BP
+ MOVQ 0x28(SP), R12
+ MOVQ 0x30(SP), R13
+ MOVQ 0x38(SP), R14
+ MOVQ 0x40(SP), R15
RET
TEXT _rt0_amd64_darwin_lib_go(SB),NOSPLIT,$0
diff --git a/src/runtime/rt0_darwin_arm.s b/src/runtime/rt0_darwin_arm.s
index d609850..cbbea80 100644
--- a/src/runtime/rt0_darwin_arm.s
+++ b/src/runtime/rt0_darwin_arm.s
@@ -25,6 +25,10 @@
MOVW R0, _rt0_arm_darwin_lib_argc<>(SB)
MOVW R1, _rt0_arm_darwin_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVW $runtime·libpreinit(SB), R3
+ CALL (R3)
+
// Create a new thread to do the runtime initialization and return.
MOVW _cgo_sys_thread_create(SB), R3
CMP $0, R3
diff --git a/src/runtime/rt0_darwin_arm64.s b/src/runtime/rt0_darwin_arm64.s
index e4e4a30..fa676c0 100644
--- a/src/runtime/rt0_darwin_arm64.s
+++ b/src/runtime/rt0_darwin_arm64.s
@@ -25,6 +25,11 @@
MOVD R0, _rt0_arm64_darwin_lib_argc<>(SB)
MOVD R1, _rt0_arm64_darwin_lib_argv<>(SB)
+
+ // Synchronous initialization.
+ MOVD $runtime·libpreinit(SB), R4
+ BL (R4)
+
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
MOVD $_rt0_arm64_darwin_lib_go(SB), R0
diff --git a/src/runtime/rt0_linux_386.s b/src/runtime/rt0_linux_386.s
index 633e806..59a30b4 100644
--- a/src/runtime/rt0_linux_386.s
+++ b/src/runtime/rt0_linux_386.s
@@ -26,6 +26,10 @@
MOVL 12(BP), AX
MOVL AX, _rt0_386_linux_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVL $runtime·libpreinit(SB), AX
+ CALL AX
+
SUBL $8, SP
// Create a new thread to do the runtime initialization.
diff --git a/src/runtime/rt0_linux_amd64.s b/src/runtime/rt0_linux_amd64.s
index 726b550..564b51c 100644
--- a/src/runtime/rt0_linux_amd64.s
+++ b/src/runtime/rt0_linux_amd64.s
@@ -23,6 +23,10 @@
MOVQ DI, _rt0_amd64_linux_lib_argc<>(SB)
MOVQ SI, _rt0_amd64_linux_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVQ $runtime·libpreinit(SB), AX
+ CALL AX
+
// Create a new thread to do the runtime initialization and return.
MOVQ _cgo_sys_thread_create(SB), AX
TESTQ AX, AX
diff --git a/src/runtime/rt0_linux_arm.s b/src/runtime/rt0_linux_arm.s
index b71a3f9..d28c15a 100644
--- a/src/runtime/rt0_linux_arm.s
+++ b/src/runtime/rt0_linux_arm.s
@@ -26,6 +26,10 @@
MOVW R0, _rt0_arm_linux_lib_argc<>(SB)
MOVW R1, _rt0_arm_linux_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVW $runtime·libpreinit(SB), R2
+ CALL (R2)
+
// Create a new thread to do the runtime initialization.
MOVW _cgo_sys_thread_create(SB), R2
CMP $0, R2
diff --git a/src/runtime/rt0_linux_arm64.s b/src/runtime/rt0_linux_arm64.s
index 4027527..2b32e35 100644
--- a/src/runtime/rt0_linux_arm64.s
+++ b/src/runtime/rt0_linux_arm64.s
@@ -20,6 +20,10 @@
MOVD R0, _rt0_arm64_linux_lib_argc<>(SB)
MOVD R1, _rt0_arm64_linux_lib_argv<>(SB)
+ // Synchronous initialization.
+ MOVD $runtime·libpreinit(SB), R4
+ BL (R4)
+
// Create a new thread to do the runtime initialization and return.
MOVD _cgo_sys_thread_create(SB), R4
CMP $0, R4
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index d9a449b..54c4686 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -408,9 +408,11 @@
)
type schedt struct {
- lock mutex
+ // accessed atomically. keep at top to ensure alignment on 32-bit systems.
+ goidgen uint64
+ lastpoll uint64
- goidgen uint64
+ lock mutex
midle muintptr // idle m's waiting for work
nmidle int32 // number of idle m's waiting for work
@@ -418,6 +420,8 @@
mcount int32 // number of m's that have been created
maxmcount int32 // maximum number of m's allowed (or die)
+ ngsys uint32 // number of system goroutines; updated atomically
+
pidle puintptr // idle p's
npidle uint32
nmspinning uint32 // See "Worker thread parking/unparking" comment in proc.go.
@@ -445,7 +449,6 @@
stopnote note
sysmonwait uint32
sysmonnote note
- lastpoll uint64
// safepointFn should be called on each P at the next GC
// safepoint if p.runSafePointFn is set.
diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go
index 75fc9bc..664c118 100644
--- a/src/runtime/runtime_test.go
+++ b/src/runtime/runtime_test.go
@@ -12,6 +12,13 @@
"unsafe"
)
+func init() {
+ // We're testing the runtime, so make tracebacks show things
+ // in the runtime. This only raises the level, so it won't
+ // override GOTRACEBACK=crash from the user.
+ SetTracebackEnv("system")
+}
+
var errf error
func errfn() error {
diff --git a/src/runtime/signal1_unix.go b/src/runtime/signal1_unix.go
index 19f37d9..abb9639 100644
--- a/src/runtime/signal1_unix.go
+++ b/src/runtime/signal1_unix.go
@@ -34,15 +34,33 @@
maskUpdatedChan chan struct{}
)
-func initsig() {
+func init() {
// _NSIG is the number of signals on this operating system.
// sigtable should describe what to do for all the possible signals.
if len(sigtable) != _NSIG {
print("runtime: len(sigtable)=", len(sigtable), " _NSIG=", _NSIG, "\n")
- throw("initsig")
+ throw("bad sigtable len")
+ }
+}
+
+var signalsOK bool
+
+// Initialize signals.
+// Called by libpreinit so runtime may not be initialized.
+//go:nosplit
+//go:nowritebarrierrec
+func initsig(preinit bool) {
+ if !preinit {
+ // It's now OK for signal handlers to run.
+ signalsOK = true
}
- // First call: basic setup.
+ // For c-archive/c-shared this is called by libpreinit with
+ // preinit == true.
+ if (isarchive || islibrary) && !preinit {
+ return
+ }
+
for i := int32(0); i < _NSIG; i++ {
t := &sigtable[i]
if t.flags == 0 || t.flags&_SigDefault != 0 {
@@ -64,6 +82,8 @@
}
}
+//go:nosplit
+//go:nowritebarrierrec
func sigInstallGoHandler(sig int32) bool {
// For some signals, we respect an inherited SIG_IGN handler
// rather than insist on installing our own default handler.
@@ -101,6 +121,7 @@
<-maskUpdatedChan
if t.flags&_SigHandling == 0 {
t.flags |= _SigHandling
+ fwdSig[sig] = getsig(int32(sig))
setsig(int32(sig), funcPC(sighandler), true)
}
}
@@ -163,6 +184,8 @@
// dieFromSignal kills the program with a signal.
// This provides the expected exit status for the shell.
// This is only called with fatal signals expected to kill the process.
+//go:nosplit
+//go:nowritebarrierrec
func dieFromSignal(sig int32) {
setsig(sig, _SIG_DFL, false)
updatesigmask(sigmask{})
diff --git a/src/runtime/signal2_unix.go b/src/runtime/signal2_unix.go
index 490a69d..3fe625f 100644
--- a/src/runtime/signal2_unix.go
+++ b/src/runtime/signal2_unix.go
@@ -14,12 +14,28 @@
// Determines if the signal should be handled by Go and if not, forwards the
// signal to the handler that was installed before Go's. Returns whether the
// signal was forwarded.
+// This is called by the signal handler, and the world may be stopped.
//go:nosplit
+//go:nowritebarrierrec
func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
if sig >= uint32(len(sigtable)) {
return false
}
fwdFn := fwdSig[sig]
+
+ if !signalsOK {
+ // The only way we can get here is if we are in a
+ // library or archive, we installed a signal handler
+ // at program startup, but the Go runtime has not yet
+ // been initialized.
+ if fwdFn == _SIG_DFL {
+ dieFromSignal(int32(sig))
+ } else {
+ sigfwd(fwdFn, sig, info, ctx)
+ }
+ return true
+ }
+
flags := sigtable[sig].flags
// If there is no handler to forward to, no need to forward.
diff --git a/src/runtime/signal_386.go b/src/runtime/signal_386.go
index 5c53582..0374f4a 100644
--- a/src/runtime/signal_386.go
+++ b/src/runtime/signal_386.go
@@ -107,6 +107,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_amd64x.go b/src/runtime/signal_amd64x.go
index 834e855..0f6700d 100644
--- a/src/runtime/signal_amd64x.go
+++ b/src/runtime/signal_amd64x.go
@@ -139,6 +139,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_arm.go b/src/runtime/signal_arm.go
index 9ea48df..3ea3938 100644
--- a/src/runtime/signal_arm.go
+++ b/src/runtime/signal_arm.go
@@ -99,6 +99,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_arm64.go b/src/runtime/signal_arm64.go
index 9a83bf0..e647c76 100644
--- a/src/runtime/signal_arm64.go
+++ b/src/runtime/signal_arm64.go
@@ -115,6 +115,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_darwin.go b/src/runtime/signal_darwin.go
index 4a26f3e..8d43724 100644
--- a/src/runtime/signal_darwin.go
+++ b/src/runtime/signal_darwin.go
@@ -50,6 +50,7 @@
func sigreturn(ctx unsafe.Pointer, infostyle uint32)
//go:nosplit
+//go:nowritebarrierrec
func sigtrampgo(fn uintptr, infostyle, sig uint32, info *siginfo, ctx unsafe.Pointer) {
if sigfwdgo(sig, info, ctx) {
sigreturn(ctx, infostyle)
@@ -85,6 +86,8 @@
}
setg(g.m.gsignal)
+ c := &sigctxt{info, ctx}
+ c.fixsigcode(sig)
sighandler(sig, info, ctx, g)
setg(g)
sigreturn(ctx, infostyle)
diff --git a/src/runtime/signal_darwin_386.go b/src/runtime/signal_darwin_386.go
index 302b3aa..7f7c22a 100644
--- a/src/runtime/signal_darwin_386.go
+++ b/src/runtime/signal_darwin_386.go
@@ -32,3 +32,25 @@
func (c *sigctxt) set_esp(x uint32) { c.regs().esp = x }
func (c *sigctxt) set_sigcode(x uint32) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint32) { c.info.si_addr = x }
+
+func (c *sigctxt) fixsigcode(sig uint32) {
+ switch sig {
+ case _SIGTRAP:
+ // OS X sets c.sigcode() == TRAP_BRKPT unconditionally for all SIGTRAPs,
+ // leaving no way to distinguish a breakpoint-induced SIGTRAP
+ // from an asynchronous signal SIGTRAP.
+ // They all look breakpoint-induced by default.
+ // Try looking at the code to see if it's a breakpoint.
+ // The assumption is that we're very unlikely to get an
+ // asynchronous SIGTRAP at just the moment that the
+ // PC started to point at unmapped memory.
+ pc := uintptr(c.eip())
+ // OS X will leave the pc just after the INT 3 instruction.
+ // INT 3 is usually 1 byte, but there is a 2-byte form.
+ code := (*[2]byte)(unsafe.Pointer(pc - 2))
+ if code[1] != 0xCC && (code[0] != 0xCD || code[1] != 3) {
+ // SIGTRAP on something other than INT 3.
+ c.set_sigcode(_SI_USER)
+ }
+ }
+}
diff --git a/src/runtime/signal_darwin_amd64.go b/src/runtime/signal_darwin_amd64.go
index dbf0448..c9ac293 100644
--- a/src/runtime/signal_darwin_amd64.go
+++ b/src/runtime/signal_darwin_amd64.go
@@ -40,3 +40,25 @@
func (c *sigctxt) set_rsp(x uint64) { c.regs().rsp = x }
func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) { c.info.si_addr = x }
+
+func (c *sigctxt) fixsigcode(sig uint32) {
+ switch sig {
+ case _SIGTRAP:
+ // OS X sets c.sigcode() == TRAP_BRKPT unconditionally for all SIGTRAPs,
+ // leaving no way to distinguish a breakpoint-induced SIGTRAP
+ // from an asynchronous signal SIGTRAP.
+ // They all look breakpoint-induced by default.
+ // Try looking at the code to see if it's a breakpoint.
+ // The assumption is that we're very unlikely to get an
+ // asynchronous SIGTRAP at just the moment that the
+ // PC started to point at unmapped memory.
+ pc := uintptr(c.rip())
+ // OS X will leave the pc just after the INT 3 instruction.
+ // INT 3 is usually 1 byte, but there is a 2-byte form.
+ code := (*[2]byte)(unsafe.Pointer(pc - 2))
+ if code[1] != 0xCC && (code[0] != 0xCD || code[1] != 3) {
+ // SIGTRAP on something other than INT 3.
+ c.set_sigcode(_SI_USER)
+ }
+ }
+}
diff --git a/src/runtime/signal_darwin_arm.go b/src/runtime/signal_darwin_arm.go
index 0f10971..24c5f5a 100644
--- a/src/runtime/signal_darwin_arm.go
+++ b/src/runtime/signal_darwin_arm.go
@@ -42,3 +42,24 @@
func (c *sigctxt) set_sigcode(x uint32) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint32) { c.info.si_addr = x }
+
+func (c *sigctxt) fixsigcode(sig uint32) {
+ switch sig {
+ case _SIGTRAP:
+ // OS X sets c.sigcode() == TRAP_BRKPT unconditionally for all SIGTRAPs,
+ // leaving no way to distinguish a breakpoint-induced SIGTRAP
+ // from an asynchronous signal SIGTRAP.
+ // They all look breakpoint-induced by default.
+ // Try looking at the code to see if it's a breakpoint.
+ // The assumption is that we're very unlikely to get an
+ // asynchronous SIGTRAP at just the moment that the
+ // PC started to point at unmapped memory.
+ pc := uintptr(c.pc())
+ // OS X will leave the pc just after the instruction.
+ code := (*uint32)(unsafe.Pointer(pc - 4))
+ if *code != 0xe7f001f0 {
+ // SIGTRAP on something other than breakpoint.
+ c.set_sigcode(_SI_USER)
+ }
+ }
+}
diff --git a/src/runtime/signal_darwin_arm64.go b/src/runtime/signal_darwin_arm64.go
index 2df4229..82f4a82 100644
--- a/src/runtime/signal_darwin_arm64.go
+++ b/src/runtime/signal_darwin_arm64.go
@@ -55,6 +55,28 @@
func (c *sigctxt) set_lr(x uint64) { c.regs().lr = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().x[28] = x }
+func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {
c.info.si_addr = (*byte)(unsafe.Pointer(uintptr(x)))
}
+
+func (c *sigctxt) fixsigcode(sig uint32) {
+ switch sig {
+ case _SIGTRAP:
+ // OS X sets c.sigcode() == TRAP_BRKPT unconditionally for all SIGTRAPs,
+ // leaving no way to distinguish a breakpoint-induced SIGTRAP
+ // from an asynchronous signal SIGTRAP.
+ // They all look breakpoint-induced by default.
+ // Try looking at the code to see if it's a breakpoint.
+ // The assumption is that we're very unlikely to get an
+ // asynchronous SIGTRAP at just the moment that the
+ // PC started to point at unmapped memory.
+ pc := uintptr(c.pc())
+ // OS X will leave the pc just after the instruction.
+ code := (*uint32)(unsafe.Pointer(pc - 4))
+ if *code != 0xd4200000 {
+ // SIGTRAP on something other than breakpoint.
+ c.set_sigcode(_SI_USER)
+ }
+ }
+}
diff --git a/src/runtime/signal_freebsd.go b/src/runtime/signal_freebsd.go
index 7c98cf3..f3411aa 100644
--- a/src/runtime/signal_freebsd.go
+++ b/src/runtime/signal_freebsd.go
@@ -48,6 +48,7 @@
}
//go:nosplit
+//go:nowritebarrierrec
func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
if sigfwdgo(sig, info, ctx) {
return
diff --git a/src/runtime/signal_mips64x.go b/src/runtime/signal_mips64x.go
index 868e993..77c2714 100644
--- a/src/runtime/signal_mips64x.go
+++ b/src/runtime/signal_mips64x.go
@@ -117,6 +117,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_openbsd.go b/src/runtime/signal_openbsd.go
index d1e48c4..d0239b1 100644
--- a/src/runtime/signal_openbsd.go
+++ b/src/runtime/signal_openbsd.go
@@ -48,6 +48,7 @@
}
//go:nosplit
+//go:nowritebarrierrec
func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
if sigfwdgo(sig, info, ctx) {
return
diff --git a/src/runtime/signal_ppc64x.go b/src/runtime/signal_ppc64x.go
index ee26348..1c868b8 100644
--- a/src/runtime/signal_ppc64x.go
+++ b/src/runtime/signal_ppc64x.go
@@ -121,6 +121,10 @@
}
}
+ if c.sigcode() == _SI_USER && signal_ignored(sig) {
+ return
+ }
+
if flags&_SigKill != 0 {
dieFromSignal(int32(sig))
}
diff --git a/src/runtime/signal_sigtramp.go b/src/runtime/signal_sigtramp.go
index 5197a3d..00ab038 100644
--- a/src/runtime/signal_sigtramp.go
+++ b/src/runtime/signal_sigtramp.go
@@ -9,7 +9,9 @@
import "unsafe"
// Continuation of the (assembly) sigtramp() logic.
+// This may be called with the world stopped.
//go:nosplit
+//go:nowritebarrierrec
func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
if sigfwdgo(sig, info, ctx) {
return
diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go
index 5cfa20f..ab7183f 100644
--- a/src/runtime/signal_windows.go
+++ b/src/runtime/signal_windows.go
@@ -191,7 +191,7 @@
// Following are not implemented.
-func initsig() {
+func initsig(preinit bool) {
}
func sigenable(sig uint32) {
diff --git a/src/runtime/sigqueue.go b/src/runtime/sigqueue.go
index 8c9951a..546d3ab 100644
--- a/src/runtime/sigqueue.go
+++ b/src/runtime/sigqueue.go
@@ -34,12 +34,13 @@
)
var sig struct {
- note note
- mask [(_NSIG + 31) / 32]uint32
- wanted [(_NSIG + 31) / 32]uint32
- recv [(_NSIG + 31) / 32]uint32
- state uint32
- inuse bool
+ note note
+ mask [(_NSIG + 31) / 32]uint32
+ wanted [(_NSIG + 31) / 32]uint32
+ ignored [(_NSIG + 31) / 32]uint32
+ recv [(_NSIG + 31) / 32]uint32
+ state uint32
+ inuse bool
}
const (
@@ -146,6 +147,7 @@
return
}
sig.wanted[s/32] |= 1 << (s & 31)
+ sig.ignored[s/32] &^= 1 << (s & 31)
sigenable(s)
}
@@ -166,12 +168,19 @@
return
}
sig.wanted[s/32] &^= 1 << (s & 31)
+ sig.ignored[s/32] |= 1 << (s & 31)
sigignore(s)
}
+// Checked by signal handlers.
+func signal_ignored(s uint32) bool {
+ return sig.ignored[s/32]&(1<<(s&31)) != 0
+}
+
// This runs on a foreign stack, without an m or a g. No stack split.
//go:nosplit
//go:norace
+//go:nowritebarrierrec
func badsignal(sig uintptr) {
cgocallback(unsafe.Pointer(funcPC(badsignalgo)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
}
diff --git a/src/runtime/sys_windows_386.s b/src/runtime/sys_windows_386.s
index e5fe88a..55cdcf4 100644
--- a/src/runtime/sys_windows_386.s
+++ b/src/runtime/sys_windows_386.s
@@ -206,7 +206,8 @@
CALL runtime·memclr(SB) // smashes AX,BX,CX
LEAL g__size(SP), BX
MOVL BX, g_m(SP)
- LEAL -8192(SP), CX
+
+ LEAL -32768(SP), CX // must be less than SizeOfStackReserve set by linker
MOVL CX, (g_stack+stack_lo)(SP)
ADDL $const__StackGuard, CX
MOVL CX, g_stackguard0(SP)
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s
index 1ca1dbb..caa18e6 100644
--- a/src/runtime/sys_windows_amd64.s
+++ b/src/runtime/sys_windows_amd64.s
@@ -243,7 +243,7 @@
LEAQ g__size(SP), BX
MOVQ BX, g_m(SP)
- LEAQ -32768(SP), CX
+ LEAQ -32768(SP), CX // must be less than SizeOfStackReserve set by linker
MOVQ CX, (g_stack+stack_lo)(SP)
ADDQ $const__StackGuard, CX
MOVQ CX, g_stackguard0(SP)
diff --git a/src/runtime/testdata/testprog/misc.go b/src/runtime/testdata/testprog/misc.go
new file mode 100644
index 0000000..237680f
--- /dev/null
+++ b/src/runtime/testdata/testprog/misc.go
@@ -0,0 +1,15 @@
+// Copyright 2016 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 main
+
+import "runtime"
+
+func init() {
+ register("NumGoroutine", NumGoroutine)
+}
+
+func NumGoroutine() {
+ println(runtime.NumGoroutine())
+}
diff --git a/src/runtime/testdata/testprogcgo/dropm.go b/src/runtime/testdata/testprogcgo/dropm.go
new file mode 100644
index 0000000..75984ea
--- /dev/null
+++ b/src/runtime/testdata/testprogcgo/dropm.go
@@ -0,0 +1,59 @@
+// Copyright 2016 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.
+
+// +build !plan9,!windows
+
+// Test that a sequence of callbacks from C to Go get the same m.
+// This failed to be true on arm and arm64, which was the root cause
+// of issue 13881.
+
+package main
+
+/*
+#include <stddef.h>
+#include <pthread.h>
+
+extern void GoCheckM();
+
+static void* thread(void* arg __attribute__ ((unused))) {
+ GoCheckM();
+ return NULL;
+}
+
+static void CheckM() {
+ pthread_t tid;
+ pthread_create(&tid, NULL, thread, NULL);
+ pthread_join(tid, NULL);
+ pthread_create(&tid, NULL, thread, NULL);
+ pthread_join(tid, NULL);
+}
+*/
+import "C"
+
+import (
+ "fmt"
+ "os"
+)
+
+func init() {
+ register("EnsureDropM", EnsureDropM)
+}
+
+var savedM uintptr
+
+//export GoCheckM
+func GoCheckM() {
+ m := runtime_getm_for_test()
+ if savedM == 0 {
+ savedM = m
+ } else if savedM != m {
+ fmt.Printf("m == %x want %x\n", m, savedM)
+ os.Exit(1)
+ }
+}
+
+func EnsureDropM() {
+ C.CheckM()
+ fmt.Println("OK")
+}
diff --git a/src/runtime/testdata/testprogcgo/dropm_stub.go b/src/runtime/testdata/testprogcgo/dropm_stub.go
new file mode 100644
index 0000000..4c3f46a
--- /dev/null
+++ b/src/runtime/testdata/testprogcgo/dropm_stub.go
@@ -0,0 +1,11 @@
+// Copyright 2016 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 main
+
+import _ "unsafe" // for go:linkname
+
+// Defined in the runtime package.
+//go:linkname runtime_getm_for_test runtime.getm
+func runtime_getm_for_test() uintptr
diff --git a/src/runtime/testdata/testprognet/signal.go b/src/runtime/testdata/testprognet/signal.go
new file mode 100644
index 0000000..24d1424
--- /dev/null
+++ b/src/runtime/testdata/testprognet/signal.go
@@ -0,0 +1,26 @@
+// Copyright 2016 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.
+
+// +build !windows,!plan9,!nacl
+
+// This is in testprognet instead of testprog because testprog
+// must not import anything (like net, but also like os/signal)
+// that kicks off background goroutines during init.
+
+package main
+
+import (
+ "os/signal"
+ "syscall"
+)
+
+func init() {
+ register("SignalIgnoreSIGTRAP", SignalIgnoreSIGTRAP)
+}
+
+func SignalIgnoreSIGTRAP() {
+ signal.Ignore(syscall.SIGTRAP)
+ syscall.Kill(syscall.Getpid(), syscall.SIGTRAP)
+ println("OK")
+}
diff --git a/src/syscall/syscall.go b/src/syscall/syscall.go
index 791bcbb..769e6b9 100644
--- a/src/syscall/syscall.go
+++ b/src/syscall/syscall.go
@@ -95,5 +95,8 @@
// use is a no-op, but the compiler cannot see that it is.
// Calling use(p) ensures that p is kept live until that point.
+// This was needed until Go 1.6 to call syscall.Syscall correctly.
+// As of Go 1.6 the compiler handles that case automatically.
+// The uses and definition of use can be removed early in the Go 1.7 cycle.
//go:noescape
func use(p unsafe.Pointer)
diff --git a/src/time/format.go b/src/time/format.go
index fc2136a..e616feb 100644
--- a/src/time/format.go
+++ b/src/time/format.go
@@ -1002,7 +1002,7 @@
// Validate the day of the month.
if day > daysIn(Month(month), year) {
- return Time{}, &ParseError{alayout, avalue, "", value, ": day of month out of range"}
+ return Time{}, &ParseError{alayout, avalue, "", value, ": day out of range"}
}
if z != nil {
diff --git a/src/time/format_test.go b/src/time/format_test.go
index b6ea9af..af950a7 100644
--- a/src/time/format_test.go
+++ b/src/time/format_test.go
@@ -233,13 +233,13 @@
case test.ok && err == nil:
// OK
case !test.ok && err != nil:
- if !strings.Contains(err.Error(), "day of month out of range") {
- t.Errorf("%q: expected 'day of month' error, got %v", test.date, err)
+ if !strings.Contains(err.Error(), "day out of range") {
+ t.Errorf("%q: expected 'day' error, got %v", test.date, err)
}
case test.ok && err != nil:
t.Errorf("%q: unexpected error: %v", test.date, err)
case !test.ok && err == nil:
- t.Errorf("%q: expected 'day of month' error, got none", test.date)
+ t.Errorf("%q: expected 'day' error, got none", test.date)
}
}
}
diff --git a/src/vendor/golang.org/x/net/http2/hpack/hpack.go b/src/vendor/golang.org/x/net/http2/hpack/hpack.go
index 329a8d0..2ea4949 100644
--- a/src/vendor/golang.org/x/net/http2/hpack/hpack.go
+++ b/src/vendor/golang.org/x/net/http2/hpack/hpack.go
@@ -41,6 +41,14 @@
Sensitive bool
}
+func (hf HeaderField) String() string {
+ var suffix string
+ if hf.Sensitive {
+ suffix = " (sensitive)"
+ }
+ return fmt.Sprintf("header field %q = %q%s", hf.Name, hf.Value, suffix)
+}
+
func (hf *HeaderField) size() uint32 {
// http://http2.github.io/http2-spec/compression.html#rfc.section.4.1
// "The size of the dynamic table is the sum of the size of
