diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 47601ecf5f57ce5e3fee455c465ae3825feb2d3b..1cd8488ea1a66ab8a21bf196c699f2b8313392ea 100644
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -1294,7 +1294,7 @@ type constSetKey struct {
// equal value and identical type has already been added, then add
// reports an error about the duplicate value.
//
-// pos provides position information for where expression n occured
+// pos provides position information for where expression n occurred
// (in case n does not have its own position information). what and
// where are used in the error message.
//
diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index d2e096d0f0fffaeb3e5faa63e0a61c1391560852..c428fb35a0701cbc1f8fae1663583f1e9b91e820 100644
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -24,7 +24,7 @@ import (
// First, we construct a directed weighted graph where vertices
// (termed "locations") represent variables allocated by statements
// and expressions, and edges represent assignments between variables
-// (with weights reperesenting addressing/dereference counts).
+// (with weights representing addressing/dereference counts).
//
// Next we walk the graph looking for assignment paths that might
// violate the invariants stated above. If a variable v's address is
@@ -33,7 +33,7 @@ import (
//
// To support interprocedural analysis, we also record data-flow from
// each function's parameters to the heap and to its result
-// parameters. This information is summarized as "paremeter tags",
+// parameters. This information is summarized as "parameter tags",
// which are used at static call sites to improve escape analysis of
// function arguments.
@@ -44,7 +44,7 @@ import (
// "location."
//
// We also model every Go assignment as a directed edges between
-// locations. The number of derefence operations minus the number of
+// locations. The number of dereference operations minus the number of
// addressing operations is recorded as the edge's weight (termed
// "derefs"). For example:
//
diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go
index 12ebfb871b491b521658d68f1a32039746c102a4..dff33ee5308c75f0bfdc043a3807e7aec0fcf5a3 100644
--- a/src/cmd/compile/internal/gc/main.go
+++ b/src/cmd/compile/internal/gc/main.go
@@ -570,7 +570,7 @@ func Main(archInit func(*Arch)) {
fcount++
}
}
- // With all types ckecked, it's now safe to verify map keys. One single
+ // With all types checked, it's now safe to verify map keys. One single
// check past phase 9 isn't sufficient, as we may exit with other errors
// before then, thus skipping map key errors.
checkMapKeys()
diff --git a/src/cmd/compile/internal/gc/sinit.go b/src/cmd/compile/internal/gc/sinit.go
index a506bfe31f2b2c4e194f86108b0b8ead5ee1641d..ae8e79d854b5e6a0e5a3313f8fc209ec5f5b6f9e 100644
--- a/src/cmd/compile/internal/gc/sinit.go
+++ b/src/cmd/compile/internal/gc/sinit.go
@@ -495,7 +495,7 @@ func isStaticCompositeLiteral(n *Node) bool {
// literal components of composite literals.
// Dynamic initialization represents non-literals and
// non-literal components of composite literals.
-// LocalCode initializion represents initialization
+// LocalCode initialization represents initialization
// that occurs purely in generated code local to the function of use.
// Initialization code is sometimes generated in passes,
// first static then dynamic.
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 6d70cdbdd0c7a0c778242913ea2cb4ff9e13b199..5e8033ac34b36571826e63f8adccca3fb693bbed 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1645,7 +1645,7 @@ var fpConvOpToSSA32 = map[twoTypes]twoOpsAndType{
twoTypes{TFLOAT64, TUINT32}: twoOpsAndType{ssa.OpCvt64Fto32U, ssa.OpCopy, TUINT32},
}
-// uint64<->float conversions, only on machines that have intructions for that
+// uint64<->float conversions, only on machines that have instructions for that
var uint64fpConvOpToSSA = map[twoTypes]twoOpsAndType{
twoTypes{TUINT64, TFLOAT32}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto32F, TUINT64},
twoTypes{TUINT64, TFLOAT64}: twoOpsAndType{ssa.OpCopy, ssa.OpCvt64Uto64F, TUINT64},
diff --git a/src/cmd/compile/internal/gc/syntax.go b/src/cmd/compile/internal/gc/syntax.go
index dec72690bf434197b9e84a8a80cd4f100cceed6f..7bd88eec17502222c57bbbf7884684adbefcf337 100644
--- a/src/cmd/compile/internal/gc/syntax.go
+++ b/src/cmd/compile/internal/gc/syntax.go
@@ -691,7 +691,7 @@ const (
ORECV // <-Left
ORUNESTR // Type(Left) (Type is string, Left is rune)
OSELRECV // Left = <-Right.Left: (appears as .Left of OCASE; Right.Op == ORECV)
- OSELRECV2 // List = <-Right.Left: (apperas as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
+ OSELRECV2 // List = <-Right.Left: (appears as .Left of OCASE; count(List) == 2, Right.Op == ORECV)
OIOTA // iota
OREAL // real(Left)
OIMAG // imag(Left)
diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index 0062dddc6c6e4550a58e8e0a5de58f4fdfbf1af9..cb49e0f7ce2e8e4b8e638653a8f4eb04feb6a3b7 100644
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1265,7 +1265,7 @@ opswitch:
}
// Map initialization with a variable or large hint is
// more complicated. We therefore generate a call to
- // runtime.makemap to intialize hmap and allocate the
+ // runtime.makemap to initialize hmap and allocate the
// map buckets.
// When hint fits into int, use makemap instead of
diff --git a/src/cmd/compile/internal/ssa/branchelim.go b/src/cmd/compile/internal/ssa/branchelim.go
index 71c947d0d52770bc58ae43449a9157c4d2c74ca1..fda0cbb9b3b0f1bac722980b6a16011b70e250bd 100644
--- a/src/cmd/compile/internal/ssa/branchelim.go
+++ b/src/cmd/compile/internal/ssa/branchelim.go
@@ -319,7 +319,7 @@ func shouldElimIfElse(no, yes, post *Block, arch string) bool {
cost := phi * 1
if phi > 1 {
// If we have more than 1 phi and some values in post have args
- // in yes or no blocks, we may have to recalucalte condition, because
+ // in yes or no blocks, we may have to recalculate condition, because
// those args may clobber flags. For now assume that all operations clobber flags.
cost += other * 1
}
diff --git a/src/cmd/compile/internal/ssa/deadstore.go b/src/cmd/compile/internal/ssa/deadstore.go
index 69616b3a883c1ede8b8db08f096972a4e6686111..ebcb571e66036623f55e7d3bb17f31314cdd4b4e 100644
--- a/src/cmd/compile/internal/ssa/deadstore.go
+++ b/src/cmd/compile/internal/ssa/deadstore.go
@@ -180,7 +180,7 @@ func elimDeadAutosGeneric(f *Func) {
}
return
case OpStore, OpMove, OpZero:
- // v should be elimated if we eliminate the auto.
+ // v should be eliminated if we eliminate the auto.
n, ok := addr[args[0]]
if ok && elim[v] == nil {
elim[v] = n
diff --git a/src/cmd/compile/internal/ssa/debug_test.go b/src/cmd/compile/internal/ssa/debug_test.go
index 73a0afb82c94d0169ce8993d44caefb3f15f56e4..28bb88a0c3c3c7eb93c562e07c9f49c77a1128f0 100644
--- a/src/cmd/compile/internal/ssa/debug_test.go
+++ b/src/cmd/compile/internal/ssa/debug_test.go
@@ -959,7 +959,7 @@ func replaceEnv(env []string, ev string, evv string) []string {
}
// asCommandLine renders cmd as something that could be copy-and-pasted into a command line
-// If cwd is not empty and different from the command's directory, prepend an approprirate "cd"
+// If cwd is not empty and different from the command's directory, prepend an appropriate "cd"
func asCommandLine(cwd string, cmd *exec.Cmd) string {
s := "("
if cmd.Dir != "" && cmd.Dir != cwd {
diff --git a/src/cmd/compile/internal/ssa/gen/PPC64Ops.go b/src/cmd/compile/internal/ssa/gen/PPC64Ops.go
index 65a183dba6dd102062cb07538f638a4b20c7598c..af727747650a7217f403e607321bf88859623166 100644
--- a/src/cmd/compile/internal/ssa/gen/PPC64Ops.go
+++ b/src/cmd/compile/internal/ssa/gen/PPC64Ops.go
@@ -222,7 +222,7 @@ func init() {
{name: "POPCNTD", argLength: 1, reg: gp11, asm: "POPCNTD"}, // number of set bits in arg0
{name: "POPCNTW", argLength: 1, reg: gp11, asm: "POPCNTW"}, // number of set bits in each word of arg0 placed in corresponding word
- {name: "POPCNTB", argLength: 1, reg: gp11, asm: "POPCNTB"}, // number of set bits in each byte of arg0 placed in corresonding byte
+ {name: "POPCNTB", argLength: 1, reg: gp11, asm: "POPCNTB"}, // number of set bits in each byte of arg0 placed in corresponding byte
{name: "FDIV", argLength: 2, reg: fp21, asm: "FDIV"}, // arg0/arg1
{name: "FDIVS", argLength: 2, reg: fp21, asm: "FDIVS"}, // arg0/arg1
diff --git a/src/cmd/compile/internal/ssa/gen/S390XOps.go b/src/cmd/compile/internal/ssa/gen/S390XOps.go
index 03c8b3de06a91781f0ac6e182a5cfcae737cdb8a..943b9c2661c86d143f226691677c3fbe5c9b00ad 100644
--- a/src/cmd/compile/internal/ssa/gen/S390XOps.go
+++ b/src/cmd/compile/internal/ssa/gen/S390XOps.go
@@ -489,7 +489,7 @@ func init() {
{name: "LoweredPanicBoundsB", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{r1, r2}}, typ: "Mem"}, // arg0=idx, arg1=len, arg2=mem, returns memory. AuxInt contains report code (see PanicBounds in generic.go).
{name: "LoweredPanicBoundsC", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{r0, r1}}, typ: "Mem"}, // arg0=idx, arg1=len, arg2=mem, returns memory. AuxInt contains report code (see PanicBounds in generic.go).
- // Constant conditon code values. The condition code can be 0, 1, 2 or 3.
+ // Constant condition code values. The condition code can be 0, 1, 2 or 3.
{name: "FlagEQ"}, // CC=0 (equal)
{name: "FlagLT"}, // CC=1 (less than)
{name: "FlagGT"}, // CC=2 (greater than)
diff --git a/src/cmd/compile/internal/ssa/gen/genericOps.go b/src/cmd/compile/internal/ssa/gen/genericOps.go
index 8933aa51eff26290875611696395778d21889805..3ca773b595eba94c97e8a4fa59e5d8ad006edf29 100644
--- a/src/cmd/compile/internal/ssa/gen/genericOps.go
+++ b/src/cmd/compile/internal/ssa/gen/genericOps.go
@@ -484,7 +484,7 @@ var genericOps = []opData{
{name: "VarDef", argLength: 1, aux: "Sym", typ: "Mem", symEffect: "None", zeroWidth: true}, // aux is a *gc.Node of a variable that is about to be initialized. arg0=mem, returns mem
{name: "VarKill", argLength: 1, aux: "Sym", symEffect: "None"}, // aux is a *gc.Node of a variable that is known to be dead. arg0=mem, returns mem
- // TODO: what's the difference betweeen VarLive and KeepAlive?
+ // TODO: what's the difference between VarLive and KeepAlive?
{name: "VarLive", argLength: 1, aux: "Sym", symEffect: "Read", zeroWidth: true}, // aux is a *gc.Node of a variable that must be kept live. arg0=mem, returns mem
{name: "KeepAlive", argLength: 2, typ: "Mem", zeroWidth: true}, // arg[0] is a value that must be kept alive until this mark. arg[1]=mem, returns mem
diff --git a/src/cmd/compile/internal/ssa/gen/main.go b/src/cmd/compile/internal/ssa/gen/main.go
index 9c0e0904b2b778e3a2f5fe0ac16f3224c625651d..ba17148fc9defccb373fd294ee1a1313d85f8e05 100644
--- a/src/cmd/compile/internal/ssa/gen/main.go
+++ b/src/cmd/compile/internal/ssa/gen/main.go
@@ -74,7 +74,7 @@ type regInfo struct {
// clobbers encodes the set of registers that are overwritten by
// the instruction (other than the output registers).
clobbers regMask
- // outpus[i] encodes the set of registers allowed for the i'th output.
+ // outputs[i] encodes the set of registers allowed for the i'th output.
outputs []regMask
}
@@ -430,7 +430,7 @@ func (a arch) Name() string {
//
// Note that there is no limit on the concurrency at the moment. On a four-core
// laptop at the time of writing, peak RSS usually reached ~230MiB, which seems
-// doable by practially any machine nowadays. If that stops being the case, we
+// doable by practically any machine nowadays. If that stops being the case, we
// can cap this func to a fixed number of architectures being generated at once.
func genLower() {
var wg sync.WaitGroup
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index ad09975a6da2d05b12d6eaf8e62c165b04c05279..2df2e1234b5c61abeb527faca8fc34afe2b62a18 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -396,7 +396,7 @@ type Node interface{}
// ast.Stmt under some limited circumstances.
type Statement interface{}
-// bodyBase is shared by all of our statement psuedo-node types which can
+// bodyBase is shared by all of our statement pseudo-node types which can
// contain other statements.
type bodyBase struct {
list []Statement
diff --git a/src/cmd/compile/internal/ssa/loopbce.go b/src/cmd/compile/internal/ssa/loopbce.go
index 5f02643ccd5454fb10ba9acd2d3ebbdfd39c9820..092e7aa35ba36e7ff9eaef8a83a74f511e439c3f 100644
--- a/src/cmd/compile/internal/ssa/loopbce.go
+++ b/src/cmd/compile/internal/ssa/loopbce.go
@@ -186,7 +186,7 @@ func findIndVar(f *Func) []indVar {
// Handle induction variables of these forms.
// KNN is known-not-negative.
// SIGNED ARITHMETIC ONLY. (see switch on b.Control.Op above)
- // Possibilitis for KNN are len and cap; perhaps we can infer others.
+ // Possibilities for KNN are len and cap; perhaps we can infer others.
// for i := 0; i <= KNN-k ; i += k
// for i := 0; i < KNN-(k-1); i += k
// Also handle decreasing.
diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go
index 8abbf615076fb7c422812e71d763501425176f84..3b7049b823e4a048e2ea82f53aea54a375c3ded1 100644
--- a/src/cmd/compile/internal/ssa/regalloc.go
+++ b/src/cmd/compile/internal/ssa/regalloc.go
@@ -411,7 +411,7 @@ func (s *regAllocState) allocReg(mask regMask, v *Value) register {
if s.f.Config.ctxt.Arch.Arch == sys.ArchWasm {
// TODO(neelance): In theory this should never happen, because all wasm registers are equal.
- // So if there is still a free register, the allocation should have picked that one in the first place insead of
+ // So if there is still a free register, the allocation should have picked that one in the first place instead of
// trying to kick some other value out. In practice, this case does happen and it breaks the stack optimization.
s.freeReg(r)
return r
@@ -489,7 +489,7 @@ func (s *regAllocState) allocValToReg(v *Value, mask regMask, nospill bool, pos
}
var r register
- // If nospill is set, the value is used immedately, so it can live on the WebAssembly stack.
+ // If nospill is set, the value is used immediately, so it can live on the WebAssembly stack.
onWasmStack := nospill && s.f.Config.ctxt.Arch.Arch == sys.ArchWasm
if !onWasmStack {
// Allocate a register.
diff --git a/src/cmd/compile/internal/ssa/sparsetree.go b/src/cmd/compile/internal/ssa/sparsetree.go
index 546da8348d6a47f66a32106be9aa06d8cd8e7b5c..fe96912c002e3ad83bb742dfdec879fd8c241f67 100644
--- a/src/cmd/compile/internal/ssa/sparsetree.go
+++ b/src/cmd/compile/internal/ssa/sparsetree.go
@@ -223,7 +223,7 @@ func (t SparseTree) domorder(x *Block) int32 {
// entry(x) < entry(y) allows cases x-dom-y and x-then-y.
// But by supposition, x does not dominate y. So we have x-then-y.
//
- // For contractidion, assume x dominates z.
+ // For contradiction, assume x dominates z.
// Then entry(x) < entry(z) < exit(z) < exit(x).
// But we know x-then-y, so entry(x) < exit(x) < entry(y) < exit(y).
// Combining those, entry(x) < entry(z) < exit(z) < exit(x) < entry(y) < exit(y).
diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index f6caa01fd22f93610c75dd54dea3ad08ff359ce2..71a2e01fa348474bde7d948e91ced8c36eb8b2a6 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -206,7 +206,7 @@ func TestMain(m *testing.M) {
// (installed in GOROOT/pkg/tool/GOOS_GOARCH).
// If these are not the same toolchain, then the entire standard library
// will look out of date (the compilers in those two different tool directories
- // are built for different architectures and have different buid IDs),
+ // are built for different architectures and have different build IDs),
// which will cause many tests to do unnecessary rebuilds and some
// tests to attempt to overwrite the installed standard library.
// Bail out entirely in this case.
diff --git a/src/cmd/go/internal/modfetch/coderepo.go b/src/cmd/go/internal/modfetch/coderepo.go
index f15ce67d46012a1b434f5006528083762731d83e..cd85bad45f8da375fe66f0334228f55b0c43f83b 100644
--- a/src/cmd/go/internal/modfetch/coderepo.go
+++ b/src/cmd/go/internal/modfetch/coderepo.go
@@ -632,7 +632,7 @@ func (r *codeRepo) findDir(version string) (rev, dir string, gomod []byte, err e
// the real module, found at a different path, usable only in
// a replace directive.
//
- // TODO(bcmills): This doesn't seem right. Investigate futher.
+ // TODO(bcmills): This doesn't seem right. Investigate further.
// (Notably: why can't we replace foo/v2 with fork-of-foo/v3?)
dir2 := path.Join(r.codeDir, r.pathMajor[1:])
file2 = path.Join(dir2, "go.mod")
diff --git a/src/cmd/go/internal/search/search.go b/src/cmd/go/internal/search/search.go
index 0167c8d7550838f0b84ee8c03f60269c1167baf6..0e420c99bdc153c8b81802b64ab3dd6a5456f884 100644
--- a/src/cmd/go/internal/search/search.go
+++ b/src/cmd/go/internal/search/search.go
@@ -241,7 +241,7 @@ func TreeCanMatchPattern(pattern string) func(name string) bool {
//
// First, /... at the end of the pattern can match an empty string,
// so that net/... matches both net and packages in its subdirectories, like net/http.
-// Second, any slash-separted pattern element containing a wildcard never
+// Second, any slash-separated pattern element containing a wildcard never
// participates in a match of the "vendor" element in the path of a vendored
// package, so that ./... does not match packages in subdirectories of
// ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
diff --git a/src/cmd/go/internal/search/search_test.go b/src/cmd/go/internal/search/search_test.go
index 0bef765fa452b586038f3e4829d519aaf501bf07..5f27daf3fb848d643882f91e0d442ebf9eaaa266 100644
--- a/src/cmd/go/internal/search/search_test.go
+++ b/src/cmd/go/internal/search/search_test.go
@@ -33,7 +33,7 @@ var matchPatternTests = `
match net net/http
not not/http not/net/http netchan
- # Second, any slash-separted pattern element containing a wildcard never
+ # Second, any slash-separated pattern element containing a wildcard never
# participates in a match of the "vendor" element in the path of a vendored
# package, so that ./... does not match packages in subdirectories of
# ./vendor or ./mycode/vendor, but ./vendor/... and ./mycode/vendor/... do.
diff --git a/src/cmd/go/internal/sumweb/client.go b/src/cmd/go/internal/sumweb/client.go
index 6973e5ac1799081ca54d3f2a657989a3d944c295..a35dbb39be9c2c7888ea3fb15218e1fdbe42cb49 100644
--- a/src/cmd/go/internal/sumweb/client.go
+++ b/src/cmd/go/internal/sumweb/client.go
@@ -107,7 +107,7 @@ func NewConn(client Client) *Conn {
}
}
-// init initiailzes the conn (if not already initialized)
+// init initializes the conn (if not already initialized)
// and returns any initialization error.
func (c *Conn) init() error {
c.initOnce.Do(c.initWork)
diff --git a/src/cmd/go/internal/tlog/tlog.go b/src/cmd/go/internal/tlog/tlog.go
index 6703656b19fa92460af377f10b86f26044918ff2..1746ed91570e453bb317a45b20c7c509cb91c866 100644
--- a/src/cmd/go/internal/tlog/tlog.go
+++ b/src/cmd/go/internal/tlog/tlog.go
@@ -121,7 +121,7 @@ func NodeHash(left, right Hash) Hash {
func StoredHashIndex(level int, n int64) int64 {
// Level L's n'th hash is written right after level L+1's 2n+1'th hash.
// Work our way down to the level 0 ordering.
- // We'll add back the orignal level count at the end.
+ // We'll add back the original level count at the end.
for l := level; l > 0; l-- {
n = 2*n + 1
}
@@ -155,7 +155,7 @@ func SplitStoredHashIndex(index int64) (level int, n int64) {
n++
indexN = x
}
- // The hash we want was commited with record n,
+ // The hash we want was committed with record n,
// meaning it is one of (0, n), (1, n/2), (2, n/4), ...
level = int(index - indexN)
return level, n >> uint(level)
diff --git a/src/cmd/go/internal/work/action.go b/src/cmd/go/internal/work/action.go
index 33b7818fb25ddea9e7c2fef586be6bdb9391a71d..0f35739976c40a3b57e9c60fde096ac2f4ee783f 100644
--- a/src/cmd/go/internal/work/action.go
+++ b/src/cmd/go/internal/work/action.go
@@ -702,7 +702,7 @@ func (b *Builder) addInstallHeaderAction(a *Action) {
}
// buildmodeShared takes the "go build" action a1 into the building of a shared library of a1.Deps.
-// That is, the input a1 represents "go build pkgs" and the result represents "go build -buidmode=shared pkgs".
+// That is, the input a1 represents "go build pkgs" and the result represents "go build -buildmode=shared pkgs".
func (b *Builder) buildmodeShared(mode, depMode BuildMode, args []string, pkgs []*load.Package, a1 *Action) *Action {
name, err := libname(args, pkgs)
if err != nil {
diff --git a/src/cmd/go/internal/work/gccgo.go b/src/cmd/go/internal/work/gccgo.go
index 24d856ca1e020aa7ff96ed2ae25095bb223f472e..cf5dba189ed67ceabaa4e1b5812e31e642b5e298 100644
--- a/src/cmd/go/internal/work/gccgo.go
+++ b/src/cmd/go/internal/work/gccgo.go
@@ -332,7 +332,7 @@ func (tools gccgoToolchain) link(b *Builder, root *Action, out, importcfg string
}
if haveShlib[filepath.Base(a.Target)] {
- // This is a shared library we want to link againt.
+ // This is a shared library we want to link against.
if !addedShlib[a.Target] {
shlibs = append(shlibs, a.Target)
addedShlib[a.Target] = true
diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index 88a447bcc8f6fbf7912c3c43d8ebb88e3929b2fa..47586ba2624f22f8e6d9967648f3f086b7937f1f 100644
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -1561,7 +1561,7 @@ func rclass(r int16) int {
return C_GOK
}
-// con32class reclassifies the constant of 32-bit instruction. Becuase the constant type is 32-bit,
+// con32class reclassifies the constant of 32-bit instruction. Because the constant type is 32-bit,
// but saved in Offset which type is int64, con32class treats it as uint32 type and reclassifies it.
func (c *ctxt7) con32class(a *obj.Addr) int {
v := uint32(a.Offset)
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index 62d41e11ebc31194d400d8af65267b41b44cc675..a3281a99e496f043bc2d8042ceda4301da237061 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -658,7 +658,7 @@ func (ctxt *Link) DwarfAbstractFunc(curfn interface{}, s *LSym, myimportpath str
}
}
-// This table is designed to aid in the creation of references betweeen
+// This table is designed to aid in the creation of references between
// DWARF subprogram DIEs.
//
// In most cases when one DWARF DIE has to refer to another DWARF DIE,
diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 1f668a0166fffd1d3ad08e601f249576bd7115a0..e7c76d6da270da25af4e04aaf2294b97b25126ab 100644
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -3055,7 +3055,7 @@ func (ab *AsmBuf) Put(b []byte) {
}
// PutOpBytesLit writes zero terminated sequence of bytes from op,
-// starting at specified offsed (e.g. z counter value).
+// starting at specified offset (e.g. z counter value).
// Trailing 0 is not written.
//
// Intended to be used for literal Z cases.
diff --git a/src/cmd/link/internal/ld/pe.go b/src/cmd/link/internal/ld/pe.go
index ab51c874ce7358d8b031518ee012035b88c28b0e..12363626ae3a80ef2bd0c19b9c9753f6ea42cd14 100644
--- a/src/cmd/link/internal/ld/pe.go
+++ b/src/cmd/link/internal/ld/pe.go
@@ -297,7 +297,7 @@ type peStringTable struct {
stringsLen int
}
-// size resturns size of string table t.
+// size returns size of string table t.
func (t *peStringTable) size() int {
// string table starts with 4-byte length at the beginning
return t.stringsLen + 4
diff --git a/src/cmd/link/internal/ld/xcoff.go b/src/cmd/link/internal/ld/xcoff.go
index b5e5f5213b62fcae2687d34602500713a6954d93..c64066acec7b7b575f3a04a746876461f64f2594 100644
--- a/src/cmd/link/internal/ld/xcoff.go
+++ b/src/cmd/link/internal/ld/xcoff.go
@@ -628,7 +628,7 @@ func logBase2(a int) uint8 {
return uint8(bits.Len(uint(a)) - 1)
}
-// Write symbols needed when a new file appared :
+// Write symbols needed when a new file appeared:
// - a C_FILE with one auxiliary entry for its name
// - C_DWARF symbols to provide debug information
// - a C_HIDEXT which will be a csect containing all of its functions
@@ -663,7 +663,7 @@ func (f *xcoffFile) writeSymbolNewFile(ctxt *Link, name string, firstEntry uint6
// Find the size of this corresponding package DWARF compilation unit.
// This size is set during DWARF generation (see dwarf.go).
dwsize = getDwsectCUSize(sect.Name, name)
- // .debug_abbrev is commun to all packages and not found with the previous function
+ // .debug_abbrev is common to all packages and not found with the previous function
if sect.Name == ".debug_abbrev" {
s := ctxt.Syms.ROLookup(sect.Name, 0)
dwsize = uint64(s.Size)
@@ -779,7 +779,7 @@ func (f *xcoffFile) writeSymbolFunc(ctxt *Link, x *sym.Symbol) []xcoffSym {
// in the current file.
// Same goes for runtime.text.X symbols.
} else if x.File == "" { // Undefined global symbol
- // If this happens, the algorithme must be redone.
+ // If this happens, the algorithm must be redone.
if currSymSrcFile.name != "" {
Exitf("undefined global symbol found inside another file")
}
diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index 5ac2098ceb0ec17bc0ee7a3f3d9c3fe5f6e04037..f04311320e6baeb31c90a3bb4b4ad8fbd101ea30 100644
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -991,7 +991,7 @@ func mutualProtocol(protos, preferenceProtos []string) (string, bool) {
return protos[0], true
}
-// hostnameInSNI converts name into an approriate hostname for SNI.
+// hostnameInSNI converts name into an appropriate hostname for SNI.
// Literal IP addresses and absolute FQDNs are not permitted as SNI values.
// See RFC 6066, Section 3.
func hostnameInSNI(name string) string {
diff --git a/src/crypto/tls/prf.go b/src/crypto/tls/prf.go
index 05b87a9b89e9a9bf7f6efe5241cb12254206fa43..aeba5fcbd71fbd3a587086f14afc25aaaa5e18d3 100644
--- a/src/crypto/tls/prf.go
+++ b/src/crypto/tls/prf.go
@@ -263,7 +263,7 @@ func (h *finishedHash) discardHandshakeBuffer() {
}
// noExportedKeyingMaterial is used as a value of
-// ConnectionState.ekm when renegotation is enabled and thus
+// ConnectionState.ekm when renegotiation is enabled and thus
// we wish to fail all key-material export requests.
func noExportedKeyingMaterial(label string, context []byte, length int) ([]byte, error) {
return nil, errors.New("crypto/tls: ExportKeyingMaterial is unavailable when renegotiation is enabled")
diff --git a/src/crypto/x509/name_constraints_test.go b/src/crypto/x509/name_constraints_test.go
index 2020e37a5b177b94b0094f639a9ca67ea7babbcb..8344240927a89ff58b65c81370ffe9b11a75731c 100644
--- a/src/crypto/x509/name_constraints_test.go
+++ b/src/crypto/x509/name_constraints_test.go
@@ -1457,7 +1457,7 @@ var nameConstraintsTests = []nameConstraintsTest{
// that we can process CA certificates in the wild that have invalid SANs.
// See https://github.com/golang/go/issues/23995
- // #77: an invalid DNS or mail SAN will not be detected if name constaint
+ // #77: an invalid DNS or mail SAN will not be detected if name constraint
// checking is not triggered.
{
roots: make([]constraintsSpec, 1),
@@ -1631,7 +1631,7 @@ func makeConstraintsCACert(constraints constraintsSpec, name string, key *ecdsa.
NotAfter: time.Unix(2000, 0),
KeyUsage: KeyUsageCertSign,
BasicConstraintsValid: true,
- IsCA: true,
+ IsCA: true,
}
if err := addConstraintsToTemplate(constraints, template); err != nil {
@@ -1668,7 +1668,7 @@ func makeConstraintsLeafCert(leaf leafSpec, key *ecdsa.PrivateKey, parent *Certi
NotAfter: time.Unix(2000, 0),
KeyUsage: KeyUsageDigitalSignature,
BasicConstraintsValid: true,
- IsCA: false,
+ IsCA: false,
}
for _, name := range leaf.sans {
diff --git a/src/database/sql/convert.go b/src/database/sql/convert.go
index 4c056a1edadfde439ca8085cbe4f5095f09b9fcd..b966ef970c17047731eed681d5a6729de15e3e54 100644
--- a/src/database/sql/convert.go
+++ b/src/database/sql/convert.go
@@ -565,7 +565,7 @@ func callValuerValue(vr driver.Valuer) (v driver.Value, err error) {
// coefficient (also known as a significand) as a []byte, and an int32 exponent.
// These are composed into a final value as "decimal = (neg) (form=finite) coefficient * 10 ^ exponent".
// A zero length coefficient is a zero value.
-// The big-endian integer coefficent stores the most significant byte first (at coefficent[0]).
+// The big-endian integer coefficient stores the most significant byte first (at coefficient[0]).
// If the form is not finite the coefficient and exponent should be ignored.
// The negative parameter may be set to true for any form, although implementations are not required
// to respect the negative parameter in the non-finite form.
diff --git a/src/database/sql/convert_test.go b/src/database/sql/convert_test.go
index 8a82891c2532a43e32d1597b4695f3ff29382c8a..2668a5ed5e76b15313142ac6a6df2e8a76e1123e 100644
--- a/src/database/sql/convert_test.go
+++ b/src/database/sql/convert_test.go
@@ -525,7 +525,7 @@ func (d *dec) Compose(form byte, negative bool, coefficient []byte, exponent int
// This isn't strictly correct, as the extra bytes could be all zero,
// ignore this for this test.
if len(coefficient) > 16 {
- return fmt.Errorf("coefficent too large")
+ return fmt.Errorf("coefficient too large")
}
copy(d.coefficient[:], coefficient)
@@ -558,7 +558,7 @@ func (d *decFinite) Compose(form byte, negative bool, coefficient []byte, expone
// This isn't strictly correct, as the extra bytes could be all zero,
// ignore this for this test.
if len(coefficient) > 16 {
- return fmt.Errorf("coefficent too large")
+ return fmt.Errorf("coefficient too large")
}
copy(d.coefficient[:], coefficient)
diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 5c5b7dc7e973e9486eb27706a0b2f5f35dc6e696..93001635bef3b6bb845fe4bf6fb0ce4494d2e5a3 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -2040,7 +2040,7 @@ func (tx *Tx) grabConn(ctx context.Context) (*driverConn, releaseConn, error) {
return nil, nil, ctx.Err()
}
- // closeme.RLock must come before the check for isDone to prevent the Tx from
+ // closemu.RLock must come before the check for isDone to prevent the Tx from
// closing while a query is executing.
tx.closemu.RLock()
if tx.isDone() {
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index f68cefe43aed5ac8243fc39b1dd8fd639933ff25..ed0099e0e94bf4e6358dfa9cedeaea567b4e7b57 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -3783,7 +3783,7 @@ func (c *ctxOnlyConn) ExecContext(ctx context.Context, q string, args []driver.N
// TestQueryExecContextOnly ensures drivers only need to implement QueryContext
// and ExecContext methods.
func TestQueryExecContextOnly(t *testing.T) {
- // Ensure connection does not implment non-context interfaces.
+ // Ensure connection does not implement non-context interfaces.
var connType driver.Conn = &ctxOnlyConn{}
if _, ok := connType.(driver.Execer); ok {
t.Fatalf("%T must not implement driver.Execer", connType)
diff --git a/src/debug/pe/file_test.go b/src/debug/pe/file_test.go
index 42d328b5471e36074f12ce4ed7703d2cc9b53e92..bc41be266910a950e711204fa5a33e347ed27e56 100644
--- a/src/debug/pe/file_test.go
+++ b/src/debug/pe/file_test.go
@@ -215,7 +215,7 @@ var fileTests = []fileTest{
// testdata/vmlinuz-4.15.0-47-generic is a trimmed down version of Linux Kernel image.
// The original Linux Kernel image is about 8M and it is not recommended to add such a big binary file to the repo.
// Moreover only a very small portion of the original Kernel image was being parsed by debug/pe package.
- // Inorder to indentify this portion, the original image was first parsed by modified debug/pe package.
+ // In order to identify this portion, the original image was first parsed by modified debug/pe package.
// Modification essentially communicated reader's positions before and after parsing.
// Finally, bytes between those positions where written to a separate file,
// generating trimmed down version Linux Kernel image used in this test case.
diff --git a/src/encoding/base32/base32.go b/src/encoding/base32/base32.go
index e14d2d49871d8621ed6b244f148a8a5f0f256d36..7b74c1ab2cfd17955b41fd4028cab167596434e1 100644
--- a/src/encoding/base32/base32.go
+++ b/src/encoding/base32/base32.go
@@ -302,7 +302,7 @@ func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err error) {
// We have reached the end and are missing padding
return n, false, CorruptInputError(olen - len(src) - j)
}
- // We have reached the end and are not expecing any padding
+ // We have reached the end and are not expecting any padding
dlen, end = j, true
break
}
diff --git a/src/go/build/build.go b/src/go/build/build.go
index f8547606aad05396213fabc3fdc4dcb52d7b9291..722fead20ee0de8cb7a7d86bd2e6acb286ad29aa 100644
--- a/src/go/build/build.go
+++ b/src/go/build/build.go
@@ -981,7 +981,7 @@ Found:
var errNoModules = errors.New("not using modules")
// importGo checks whether it can use the go command to find the directory for path.
-// If using the go command is not appopriate, importGo returns errNoModules.
+// If using the go command is not appropriate, importGo returns errNoModules.
// Otherwise, importGo tries using the go command and reports whether that succeeded.
// Using the go command lets build.Import and build.Context.Import find code
// in Go modules. In the long term we want tools to use go/packages (currently golang.org/x/tools/go/packages),
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 0a62f4beaf4f5a678a6ab81be14a3105375e05aa..fb660b5cc888442e20faa0c77cd4c6cbae6df933 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -362,7 +362,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
// convert or check untyped argument
if isUntyped(x.typ) {
if x.mode == constant_ {
- // an untyped constant number can alway be considered
+ // an untyped constant number can always be considered
// as a complex constant
if isNumeric(x.typ) {
x.typ = Typ[UntypedComplex]
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 6220794718df99fc56d7076f650a709af1ff72a6..1400e0f00b5de4047ad9a4b233a6270986d68b4b 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -439,7 +439,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
// TODO(gri) This only works because we call LookupFieldOrMethod
// _before_ calling NewMethodSet: LookupFieldOrMethod completes
- // any incomplete interfaces so they are avaible to NewMethodSet
+ // any incomplete interfaces so they are available to NewMethodSet
// (which assumes that interfaces have been completed already).
typ := x.typ
if x.mode == variable {
diff --git a/src/image/gif/writer_test.go b/src/image/gif/writer_test.go
index 0bc24d1beec47476c4ada6a9c6613480a7600b7e..b619961787dab9175541502c1cbf6752b8fc1969 100644
--- a/src/image/gif/writer_test.go
+++ b/src/image/gif/writer_test.go
@@ -52,7 +52,7 @@ func averageDelta(m0, m1 image.Image) int64 {
}
// averageDeltaBounds returns the average delta in RGB space. The average delta is
-// calulated in the specified bounds.
+// calculated in the specified bounds.
func averageDeltaBound(m0, m1 image.Image, b0, b1 image.Rectangle) int64 {
var sum, n int64
for y := b0.Min.Y; y < b0.Max.Y; y++ {
diff --git a/src/internal/bytealg/count_ppc64x.s b/src/internal/bytealg/count_ppc64x.s
index 7abdce1954f56f5665974481446a071bd62d56e6..a64d7d792d0d7e2a2d23d7541b8d1a0540818ec0 100644
--- a/src/internal/bytealg/count_ppc64x.s
+++ b/src/internal/bytealg/count_ppc64x.s
@@ -49,7 +49,7 @@ TEXT countbytebody<>(SB), NOSPLIT|NOFRAME, $0-0
cmploop:
LXVW4X (R3), VS32 // load bytes from string
- // when the bytes match, the corresonding byte contains all 1s
+ // when the bytes match, the corresponding byte contains all 1s
VCMPEQUB V1, V0, V2 // compare bytes
VPOPCNTD V2, V3 // each double word contains its count
VADDUDM V3, V5, V5 // accumulate bit count in each double word
diff --git a/src/internal/cpu/cpu.go b/src/internal/cpu/cpu.go
index 76fc878abe69c9ea9603ac62a2ff2afcef7f846d..f326b063321a745ed06ad6488c763bdf2c498256 100644
--- a/src/internal/cpu/cpu.go
+++ b/src/internal/cpu/cpu.go
@@ -160,7 +160,7 @@ type option struct {
// processOptions enables or disables CPU feature values based on the parsed env string.
// The env string is expected to be of the form cpu.feature1=value1,cpu.feature2=value2...
-// where feature names is one of the architecture specifc list stored in the
+// where feature names is one of the architecture specific list stored in the
// cpu packages options variable and values are either 'on' or 'off'.
// If env contains cpu.all=off then all cpu features referenced through the options
// variable are disabled. Other feature names and values result in warning messages.
diff --git a/src/math/big/int.go b/src/math/big/int.go
index 23221c083d0a0ff5f2e25e5f0ccbd0c02608e9f0..f4d9a08d72916be704f312270ffd9f93bd63fbe9 100644
--- a/src/math/big/int.go
+++ b/src/math/big/int.go
@@ -468,7 +468,7 @@ func (x *Int) TrailingZeroBits() uint {
// If m == nil or m == 0, z = x**y unless y <= 0 then z = 1. If m > 0, y < 0,
// and x and n are not relatively prime, z is unchanged and nil is returned.
//
-// Modular exponentation of inputs of a particular size is not a
+// Modular exponentiation of inputs of a particular size is not a
// cryptographically constant-time operation.
func (z *Int) Exp(x, y, m *Int) *Int {
// See Knuth, volume 2, section 4.6.3.
diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index b23e68f7b3146b199f19a8f72073e0f0e0fd8d35..44dbbef43fe5697772a1526323369141937bdf7b 100644
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -437,7 +437,7 @@ func (tr *transportRequest) setError(err error) {
tr.mu.Unlock()
}
-// useRegisteredProtocol reports whether an alternate protocol (as reqistered
+// useRegisteredProtocol reports whether an alternate protocol (as registered
// with Transport.RegisterProtocol) should be respected for this request.
func (t *Transport) useRegisteredProtocol(req *Request) bool {
if req.URL.Scheme == "https" && req.requiresHTTP1() {
@@ -1903,7 +1903,7 @@ func (pc *persistConn) readLoop() {
}
return
}
- pc.readLimit = maxInt64 // effictively no limit for response bodies
+ pc.readLimit = maxInt64 // effectively no limit for response bodies
pc.mu.Lock()
pc.numExpectedResponses--
diff --git a/src/net/interface_unix_test.go b/src/net/interface_unix_test.go
index 20e75cd03679597bc97ac508771197badc9816f6..6a2b7f1a88b2051d29be1d9d7bb3210c20699e9a 100644
--- a/src/net/interface_unix_test.go
+++ b/src/net/interface_unix_test.go
@@ -186,7 +186,7 @@ func TestInterfaceArrivalAndDepartureZoneCache(t *testing.T) {
}
// Ensure zoneCache is filled:
- _, _ = Listen("tcp", "[fe80::1%nonexistant]:0")
+ _, _ = Listen("tcp", "[fe80::1%nonexistent]:0")
ti := &testInterface{local: "fe80::1"}
if err := ti.setLinkLocal(0); err != nil {
@@ -200,7 +200,7 @@ func TestInterfaceArrivalAndDepartureZoneCache(t *testing.T) {
time.Sleep(3 * time.Millisecond)
// If Listen fails (on Linux with “bind: invalid argument”), zoneCache was
- // not updated when encountering a nonexistant interface:
+ // not updated when encountering a nonexistent interface:
ln, err := Listen("tcp", "[fe80::1%"+ti.name+"]:0")
if err != nil {
t.Fatal(err)
diff --git a/src/net/url/url.go b/src/net/url/url.go
index f29e658af9af13b5a718001332251e0a71127e32..bd706eac84aab72265cb0e7c558c1854be45a5c5 100644
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -449,7 +449,7 @@ func getscheme(rawurl string) (scheme, path string, err error) {
return "", rawurl, nil
}
-// split slices s into two substrings separated by the first occurence of
+// split slices s into two substrings separated by the first occurrence of
// sep. If cutc is true then sep is included with the second substring.
// If sep does not occur in s then s and the empty string is returned.
func split(s string, sep byte, cutc bool) (string, string) {
diff --git a/src/os/file.go b/src/os/file.go
index 46ae1a46aa56b68afe8cf9dd9a3e9e52d63f2134..9afc0ba360b8ce57cb5a45c73cf2ab6ce996ae37 100644
--- a/src/os/file.go
+++ b/src/os/file.go
@@ -250,7 +250,7 @@ func Mkdir(name string, perm FileMode) error {
return nil
}
-// setStickyBit adds ModeSticky to the permision bits of path, non atomic.
+// setStickyBit adds ModeSticky to the permission bits of path, non atomic.
func setStickyBit(name string) error {
fi, err := Stat(name)
if err != nil {
diff --git a/src/runtime/map_benchmark_test.go b/src/runtime/map_benchmark_test.go
index cf04ead11561e29af86afbab80f59503b68ecedf..bae1aa0dbd6d41f2ac842009c5732182228297b1 100644
--- a/src/runtime/map_benchmark_test.go
+++ b/src/runtime/map_benchmark_test.go
@@ -251,7 +251,7 @@ func BenchmarkMapLast(b *testing.B) {
}
func BenchmarkMapCycle(b *testing.B) {
- // Arrange map entries to be a permuation, so that
+ // Arrange map entries to be a permutation, so that
// we hit all entries, and one lookup is data dependent
// on the previous lookup.
const N = 3127
diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 45a9eb2b2aa9e208ee75d27986dc856a5e64fd39..284e6698d127903bcbfc096224a8cb92d9507d0d 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -74,7 +74,7 @@ func heapRetained() uint64 {
// its rate and RSS goal.
//
// The RSS goal is based on the current heap goal with a small overhead
-// to accomodate non-determinism in the allocator.
+// to accommodate non-determinism in the allocator.
//
// The pacing is based on scavengePageRate, which applies to both regular and
// huge pages. See that constant for more information.
diff --git a/src/runtime/os2_aix.go b/src/runtime/os2_aix.go
index d9b94d438c2f8e1a067f85fa5d7212cf3f180eba..b79fa08dc2ff691d26a2be08812ab0787c28ad01 100644
--- a/src/runtime/os2_aix.go
+++ b/src/runtime/os2_aix.go
@@ -6,7 +6,7 @@
// Pollset syscalls are in netpoll_aix.go.
// The implementation is based on Solaris and Windows.
// Each syscall is made by calling its libc symbol using asmcgocall and asmsyscall6
-// asssembly functions.
+// assembly functions.
package runtime
diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index d5af836f4e33f06fec11d7fef9960a31b3e03361..567c567000da289d38c5c84290172e524a877868 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -775,7 +775,7 @@ func newosproc(mp *m) {
func newosproc0(mp *m, stk unsafe.Pointer) {
// TODO: this is completely broken. The args passed to newosproc0 (in asm_amd64.s)
// are stacksize and function, not *m and stack.
- // Check os_linux.go for an implemention that might actually work.
+ // Check os_linux.go for an implementation that might actually work.
throw("bad newosproc0")
}
diff --git a/src/runtime/pprof/label_test.go b/src/runtime/pprof/label_test.go
index 240445f098e291b89513cf9865e3260c9d30ca30..de39d85d3af5a4221d398df907dc59623ff78546 100644
--- a/src/runtime/pprof/label_test.go
+++ b/src/runtime/pprof/label_test.go
@@ -24,7 +24,7 @@ func (s labelSorter) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s labelSorter) Less(i, j int) bool { return s[i].key < s[j].key }
func TestContextLabels(t *testing.T) {
- // Background context starts with no lablels.
+ // Background context starts with no labels.
ctx := context.Background()
labels := labelsSorted(ctx)
if len(labels) != 0 {
diff --git a/test/closure2.go b/test/closure2.go
index 4d61b45d3f42fa3461290645e48c35fc3a8f3c5f..e4db05d8846cec75449a717e30fbbd9f8499a14d 100644
--- a/test/closure2.go
+++ b/test/closure2.go
@@ -74,7 +74,7 @@ func main() {
for i := range [2]int{} {
if i == 0 {
g = func() int {
- return i // test that we capture by ref here, i is mutated on every interation
+ return i // test that we capture by ref here, i is mutated on every interaction
}
}
}
@@ -90,7 +90,7 @@ func main() {
q++
g = func() int {
return q // test that we capture by ref here
- // q++ must on a different decldepth than q declaration
+ // q++ must on a different decldepth than q declaration
}
}
if g() != 2 {
@@ -108,7 +108,7 @@ func main() {
}()] = range [2]int{} {
g = func() int {
return q // test that we capture by ref here
- // q++ must on a different decldepth than q declaration
+ // q++ must on a different decldepth than q declaration
}
}
if g() != 2 {
diff --git a/test/finprofiled.go b/test/finprofiled.go
index 0eb801a4bde2d1fd0be361ec4a3e74a2323a47db..ca7e3c81dc8a47f496c5cc2ce824822635d86566 100644
--- a/test/finprofiled.go
+++ b/test/finprofiled.go
@@ -23,7 +23,7 @@ func main() {
// only for middle bytes. The finalizer resurrects that object.
// As the result, all allocated memory must stay alive.
const (
- N = 1 << 20
+ N = 1 << 20
tinyBlockSize = 16 // runtime._TinySize
)
hold := make([]*int32, 0, N)
@@ -36,7 +36,7 @@ func main() {
}
}
// Finalize as much as possible.
- // Note: the sleep only increases probility of bug detection,
+ // Note: the sleep only increases probability of bug detection,
// it cannot lead to false failure.
for i := 0; i < 5; i++ {
runtime.GC()
diff --git a/test/fixedbugs/issue24339.go b/test/fixedbugs/issue24339.go
index 0670becdfe1eada7b3b23624704a401df3084585..502c575ec84096909c78143fd1bd5b42b860ec88 100644
--- a/test/fixedbugs/issue24339.go
+++ b/test/fixedbugs/issue24339.go
@@ -6,7 +6,7 @@
package p
-// Use a diffent line number for each token so we can
+// Use a different line number for each token so we can
// check that the error message appears at the correct
// position.
var _ = struct{}{ /*line :20:1*/foo /*line :21:1*/: /*line :22:1*/0 }
diff --git a/test/index.go b/test/index.go
index d73d137ddae58da5d6751a9f7abbc736222874d2..91195ad632bea77a97f4f69457b89e74c4eea7e5 100644
--- a/test/index.go
+++ b/test/index.go
@@ -251,7 +251,7 @@ func main() {
if c == "" && (i == "fgood" || i == "fbad") {
return
}
- // Integral float constat is ok.
+ // Integral float constant is ok.
if c == "c" && n == "" && i == "fgood" {
if pass == 0 {
fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni)
diff --git a/test/ken/modconst.go b/test/ken/modconst.go
index d88cf100321d1e4cda890cc1190d0a5e6b03bae2..c27bf64bdf501f67ed681628662e1c978f7b2e80 100644
--- a/test/ken/modconst.go
+++ b/test/ken/modconst.go
@@ -4,7 +4,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Test integer modulus by contstants.
+// Test integer modulus by constants.
package main
diff --git a/test/opt_branchlikely.go b/test/opt_branchlikely.go
index 84de32179f38a0a4b8e99e729c48a1b1cf8acc44..884c34916e90574ece4048fc6cc3ad4ffba9b933 100644
--- a/test/opt_branchlikely.go
+++ b/test/opt_branchlikely.go
@@ -1,6 +1,6 @@
// +build amd64
// errorcheck -0 -d=ssa/likelyadjust/debug=1,ssa/insert_resched_checks/off
-// rescheduling check insertion is turend off because the inserted conditional branches perturb the errorcheck
+// rescheduling check insertion is turned off because the inserted conditional branches perturb the errorcheck
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
diff --git a/test/strength.go b/test/strength.go
index 94d589c240babb1f0968a856d0377ee0c2570dee..823d05af085b504b4f1a3246c8b96bedf647a4c8 100644
--- a/test/strength.go
+++ b/test/strength.go
@@ -5,7 +5,7 @@
// license that can be found in the LICENSE file.
// Generate test of strength reduction for multiplications
-// with contstants. Especially useful for amd64/386.
+// with constants. Especially useful for amd64/386.
package main