i++
}
return hd
-
}
// TODO: Delete when we switch to bisect-only.
t.Logf(m)
- yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:30)")
+ yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:29)")
nCount := strings.Count(m, "shared")
if yCount != 1 {
t.Logf(m)
- yCount := strings.Count(m, "opt-122.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-122.go:32)")
+ yCount := strings.Count(m, "opt-122.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-122.go:31)")
nCount := strings.Count(m, "shared")
if yCount != 1 {
t.Logf(m) // expect error
- yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:30)")
+ yCount := strings.Count(m, "opt.go:16:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt.go:29)")
nCount := strings.Count(m, "shared")
if yCount != 0 {
t.Logf(m) // expect error
- yCount := strings.Count(m, "opt-121.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-121.go:32)")
+ yCount := strings.Count(m, "opt-121.go:18:6: loop variable private now per-iteration, heap-allocated (loop inlined into ./opt-121.go:31)")
nCount := strings.Count(m, "shared")
if yCount != 0 {
a = append(a, &private)
}
return a
-
}
//go:noinline
a = append(a, &private)
}
return a
-
}
//go:noinline
a = append(a, &private)
}
return a
-
}
//go:noinline
v.AddArg(sp)
}
return v
-
}
func (f *Func) Frontend() Frontend { return f.fe }
ret += 1
}
return ret
-
}
func fallthrough_ssa(a int) int {
ret++
}
return ret
-
}
func testFallthrough(t *testing.T) {
}
}
return textp, nil
-
}
// Convert symbol xcoff type to sym.SymKind
func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool {
ld.Exitf("adddynrel currently unimplemented for MIPS")
return false
-
}
emitReloc(ld.XCOFF_R_REF|0x3F<<8, 0)
}
return true
-
}
func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, ri int, sectoff int64) bool {
}
return nvargs, nil
-
}
// convertAssign is the same as convertAssignRows, but without the optional
b = append(b, magic64...)
b = appendUint64(b, uint64(*s))
return b, nil
-
}
func (s *sum64a) MarshalBinary() ([]byte, error) {
}
}
return m.ShouldEnable(h)
-
}
// Writer is the same interface as io.Writer.
c := l.clone()
c.handler = l.handler.WithGroup(name)
return c
-
}
// New creates a new Logger with the given non-nil Handler.
func alike32(x, y float32) bool {
// we can ignore NaNs
return x == y && math.Signbit(float64(x)) == math.Signbit(float64(y))
-
}
func alike64(x, y float64) bool {
// we can ignore NaNs
return x == y && math.Signbit(x) == math.Signbit(y)
-
}
func TestFloatMantExp(t *testing.T) {
break
}
return
-
}
func strSliceContains(ss []string, s string) bool {
dir = "/tmp"
}
return dir
-
}
// Chdir changes the current working directory to the file,
}
// Note that in this case we can't return a valid errno value.
return write2(fd, uintptr(p), n)
-
}
//go:nosplit
throw("syscall sysconf")
}
return r
-
}
// pthread functions returns its error code in the main return value
//go:linkname reflect_resolveTextOff reflect.resolveTextOff
func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
return toRType((*_type)(rtype)).textOff(textOff(off))
-
}
// reflectlite_resolveNameOff resolves a name offset from a base pointer.
func syscall_fcntl1(fd, cmd, arg uintptr) (val, err uintptr) {
val, err = syscall3(&libc_fcntl, fd, cmd, arg)
return
-
}
//go:linkname syscall_forkx syscall.forkx
return b.a + b.b + b.c + b.x[0] + b.x[1] + int(d[0]) + int(d[1]) + int(d[2])
}
return n
-
}
//go:noinline
func (a *ActionNode) Copy() Node {
return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
-
}
// CommandNode holds a command (a pipeline inside an evaluating action).
// ppc64x: -"MOVB", "ANDCC\t[$]247,"
z = uint64(uint8(a)) & 0x3F7
return
-
}
// Verify zero-extended values are not sign-extended under a bit mask (#61297)
// ppc64x: -"MOVH\t", -"ANDCC", "MOVHZ"
y = uint64(b) & 0xFFFF
return
-
}
// Verify rotate and mask instructions, and further simplified instructions for small types
func extrashift_load_uint32(b []byte) uint32 {
// amd64:`MOVL\s\([A-Z]+\)`,`SHLL\s[$]2`,-`MOV[BW]`,-`OR`
return uint32(b[0])<<2 | uint32(b[1])<<10 | uint32(b[2])<<18 | uint32(b[3])<<26
-
}
func outoforder_load_uint32(b []byte) uint32 {
ret += int64(int8(x & 0x1100000000000011))
return ret
-
}
func noIntermediateExtension(a, b, c uint32) uint32 {
return nil
}
return nil
-
}
// assigning to an array element is like assigning to the array
return nil
}
return nil
-
}
// assigning to an array element is like assigning to the array
func doStuff(data []byte) uint64 {
return hashBytesRaw(data[0], data[1], data[2], data[3], data[7])
-
}
func New[T any](f func(a, b T) bool) Eq[T] {
return EqFunc[T](f)
-
}
func Equal(a, b []byte) bool {
func (r ApplicativeFunctor2[H, HT, A1, A2, R]) Ap(a A1) ApplicativeFunctor1[Cons[A1, H], A1, A2, R] {
return r.ApOption(Some(a))
-
}
func Applicative2[A1, A2, R any](fn Func2[A1, A2, R]) ApplicativeFunctor2[Nil, Nil, A1, A2, R] {
return x
}
return y
-
}
// Min returns the minimum element of `nums`.