}
// Disable GC for the duration of the test.
- // This avoids a potential GC deadlock when spinning in uninterruptable ASM below #49695.
+ // This avoids a potential GC deadlock when spinning in uninterruptible ASM below #49695.
defer debug.SetGCPercent(debug.SetGCPercent(-1))
// SetGCPercent waits until the mark phase is over, but the runtime
// also preempts at the start of the sweep phase, so make sure that's
return false
}
}
- return indenticalOrigin(x, y)
+ return identicalOrigin(x, y)
}
case *TypeParam:
}
// identicalOrigin reports whether x and y originated in the same declaration.
-func indenticalOrigin(x, y *Named) bool {
+func identicalOrigin(x, y *Named) bool {
// TODO(gri) is this correct?
return x.Origin().obj == y.Origin().obj
}
return false
}
}
- return indenticalOrigin(x, y)
+ return identicalOrigin(x, y)
}
case *TypeParam:
// The result of any version query for a given module — even "upgrade" or
// "patch" — is always relative to the build list at the start of
// the 'go get' command, not an intermediate state, and is therefore
- // deterministic and therefore cachable, and the constraints on the
+ // deterministic and therefore cacheable, and the constraints on the
// selected version of each module can only narrow as we iterate.
//
// "all" is functionally very similar to a wildcard pattern. The set of
7. Move large constants to vector registers.
Go asm uses VMOVQ/VMOVD/VMOVS to move 128-bit, 64-bit and 32-bit constants into vector registers, respectively.
-And for a 128-bit interger, it take two 64-bit operands, for the low and high parts separately.
+And for a 128-bit integer, it take two 64-bit operands, for the low and high parts separately.
Examples:
// contentHashSection returns a mnemonic for s's section.
// The goal is to prevent content-addressability from moving symbols between sections.
// contentHashSection only distinguishes between sets of sections for which this matters.
-// Allowing flexibility increases the effectiveness of content-addressibility.
+// Allowing flexibility increases the effectiveness of content-addressability.
// But in some cases, such as doing addressing based on a base symbol,
// we need to ensure that a symbol is always in a particular section.
// Some of these conditions are duplicated in cmd/link/internal/ld.(*Link).symtab.
type padJumpsCtx int32
func makePjcCtx(ctxt *obj.Link) padJumpsCtx {
- // Disable jump padding on 32 bit builds by settting
+ // Disable jump padding on 32 bit builds by setting
// padJumps to 0.
if ctxt.Arch.Family == sys.I386 {
return padJumpsCtx(0)
// Test that a failed compilation doesn't leave around an executable encoder.
// Issue 3723.
-func TestMutipleEncodingsOfBadType(t *testing.T) {
+func TestMultipleEncodingsOfBadType(t *testing.T) {
x := Bug4Public{
Name: "name",
Secret: Bug4Secret{1},
return false
}
}
- return indenticalOrigin(x, y)
+ return identicalOrigin(x, y)
}
case *TypeParam:
}
// identicalOrigin reports whether x and y originated in the same declaration.
-func indenticalOrigin(x, y *Named) bool {
+func identicalOrigin(x, y *Named) bool {
// TODO(gri) is this correct?
return x.Origin().obj == y.Origin().obj
}
return false
}
}
- return indenticalOrigin(x, y)
+ return identicalOrigin(x, y)
}
case *TypeParam:
E ((z)+|a)* zabcde (0,2)(1,2)
-#{E a+? aaaaaa (0,1) no *? +? mimimal match ops
+#{E a+? aaaaaa (0,1) no *? +? minimal match ops
#E (a) aaa (0,1)(0,1)
#E (a*?) aaa (0,0)(0,0)
#E (a)*? aaa (0,0)
// any C on the call stack, which there will be after this point. If
// there isn't, we can use frame pointer unwinding to collect call
// stacks efficiently. This will be the case for the first Go-to-C call
- // on a stack, so it's prefereable to update it here, after we emit a
+ // on a stack, so it's preferable to update it here, after we emit a
// trace event in entersyscall above.
mp.ncgo++
}
// markProfileEmitted signals the runtime/coverage machinery that
-// coverate data output files have already been written out, and there
+// coverage data output files have already been written out, and there
// is no need to take any additional action at exit time. This
// function is called (via linknamed reference) from the
// coverage-related boilerplate code in _testmain.go emitted for go
// The gcBlackenEnabled check in malloc races with the
// store that clears it but an atomic check in every malloc
// would be a performance hit.
- // Instead we recheck it here on the non-preemptable system
+ // Instead we recheck it here on the non-preemptible system
// stack to determine if we should perform an assist.
// GC is done, so ignore any remaining debt.
// Test that we call the proper race detector function when c.elemsize==0.
// See https://github.com/golang/go/issues/42598
-func TestNoRaceElemetSize0(t *testing.T) {
+func TestNoRaceElemSize0(t *testing.T) {
var x, y int
var c = make(chan struct{}, 2)
c <- struct{}{}
used to run the test. After writing tests for a newly added codegen
transformation, it can be useful to first run the test harness with a
toolchain from a released Go version (and verify that the new tests
-fail), and then re-runnig the tests using the devel toolchain.
+fail), and then re-running the tests using the devel toolchain.
- Regexps comments syntax