LinuxdynldMusl: "/lib/ld-musl-i386.so.1",
			Freebsddynld:   "/usr/libexec/ld-elf.so.1",
			Openbsddynld:   "/usr/libexec/ld.so",
			Netbsddynld:    "/usr/libexec/ld.elf_so",
			Solarisdynld:   "/lib/ld.so.1",

			Reloc1:    elfreloc1,
			RelocSize: 8,
			SetupPLT:  elfsetupplt,
		},
	}

	return arch, theArch
}

func archinit(ctxt *ld.Link) {
	switch ctxt.HeadType {
	default:

func TestAllocationsDecode(t *testing.T) {
	testenv.SkipIfOptimizationOff(t)

	for _, tt := range decodeTests {
		allocs := testing.AllocsPerRun(10, func() {
			out := Decode(tt.in)
			if out == nil {
				t.Errorf("Decode(%x) = nil", tt.in)
			}
		})
		if allocs > 0 {
			t.Errorf("Decode allocated %v times", allocs)
		}
	}
}

func TestDecode(t *testing.T) {
	for _, tt := range decodeTests {

// We have a limit of 1GB for stack frames.
// Make sure we include the callee args section.

package main

type Big = [400e6]byte

func f() { // GC_ERROR "stack frame too large"
	// Note: This test relies on the fact that we currently always
	// spill function-results to the stack, even if they're so
	// large that we would normally heap allocate them. If we ever
	// improve the backend to spill temporaries to the heap, this

	values := []int64{0, 0}
	var locs []uint64
	expandedStack := pprof_makeProfStack()
	for _, r := range records {
		values[0] = r.Count
		values[1] = int64(float64(r.Cycles) / cpuGHz)
		// For count profiles, all stack addresses are
		// return PCs, which is what appendLocsForStack expects.
		n := pprof_fpunwindExpand(expandedStack[:], r.Stack)
		locs = b.appendLocsForStack(locs[:0], expandedStack[:n])

}

type Reloc32 struct {
	Rvaddr  uint32 // (virtual) address of reference
	Rsymndx uint32 // Index into symbol table
	Rsize   uint8  // Sign and reloc bit len
	Rtype   uint8  // Toc relocation type
}

type Reloc64 struct {
	Rvaddr  uint64 // (virtual) address of reference
	Rsymndx uint32 // Index into symbol table
	Rsize   uint8  // Sign and reloc bit len
	Rtype   uint8  // Toc relocation type

		// The last ID of the userns range (allocated+userNsLength) should be within bounds.
		assert.True(t, allocated <= minimumMappingUID+mappingLen-userNsLength)
		allocs = append(allocs, allocated)
	}
	for i, v := range allocs {
		assert.Equal(t, true, m.isSet(v), "m.isSet(%d) should be true", v)
		m.Release(types.UID(fmt.Sprintf("%d", i)))
		assert.Equal(t, false, m.isSet(v), "m.isSet(%d) should be false", v)

	type simpleWriter struct { // hide bytes.Buffer's WriteString
		Writer
	}
	mw := MultiWriter(simpleWriter{&sink1}, simpleWriter{&sink2})
	allocs := int(testing.AllocsPerRun(1000, func() {
		WriteString(mw, "foo")
	}))
	if allocs != 1 {
		t.Errorf("num allocations = %d; want 1", allocs)
	}
}

type writeStringChecker struct{ called bool }

func (c *writeStringChecker) WriteString(s string) (n int, err error) {

		s := utilrand.String(size)
		f := func() {
			b := toBytes(s)
			if len(b) != size {
				t.Errorf("invalid length: %d", len(b))
			}
		}
		allocs := testing.AllocsPerRun(100, f)
		if allocs > 0 {
			t.Errorf("expected zero allocations, got %v", allocs)
		}
	})

	t.Run("toString semantics", func(t *testing.T) {
		t.Parallel()

		b := make([]byte, size)
		if _, err := rand.Read(b); err != nil {

// trigger the generation of wrapper functions with no
// clear line number (they end up using line 1), and those
// would have annotations printed if we used -live=1,
// like the live.go test does.
// Instead, this test relies on the fact that the liveness
// analysis turns any non-live parameter on entry into
// a compile error. Compiling successfully means that bug
// has been avoided.

package main

        int result = BigIntegerMath.log2(x, mode);
        assertTrue(ZERO.setBit(result).compareTo(x) >= 0);
        assertTrue(result == 0 || ZERO.setBit(result - 1).compareTo(x) < 0);
      }
    }
  }

  // Relies on the correctness of isPowerOfTwo(BigInteger).
  public void testLog2Exact() {
    for (BigInteger x : POSITIVE_BIGINTEGER_CANDIDATES) {
      // We only expect an exception if x was not a power of 2.