Max_protection   int32
	Inheritance      uint32
	Shared           int32
	Reserved         int32
	Offset           [8]byte // This is hand-edited since godefs generates: Pad_cgo_0 [8]byte. Cannot use uint64 due to alignment.
	Behavior         int32
	User_wired_count uint16
	Pad_cgo_1        [2]byte
}

const (
	_VM_PROT_READ    = 0x1
	_VM_PROT_WRITE   = 0x2
	_VM_PROT_EXECUTE = 0x4

	_MACH_SEND_INVALID_DEST = 0x10000003

    void (*deallocator)(void* data, size_t len, void* arg),
    void* deallocator_arg);

// Returns the alignment, in bytes, required for allocating aligned tensors.
//
// This can be used in combination with TF_NewTensor to manually manage
// memory while ensuring the resulting tensors satisfy TensorFlow's
// memory alignment preferences.
TF_CAPI_EXPORT extern size_t TF_TensorDefaultAlignment();

// Allocate and return a new Tensor.
//

	out2 := `0x0010\s00016\s\(.*\)\tMOVD\t\$2,\sR2`
	var testCases = []struct {
		name string
		code []byte
		out  string
	}{
		{"8-byte alignment", code1, out1},
		{"16-byte alignment", code2, out2},
	}

	for _, test := range testCases {
		if err := os.WriteFile(tmpfile, test.code, 0644); err != nil {
			t.Fatal(err)
		}

	MOV	X13, X5
use_a_len:
	BEQZ	X5, cmp_len

	MOV	$32, X6
	BLT	X5, X6, check8_unaligned

	// Check alignment - if alignment differs we have to do one byte at a time.
	AND	$7, X10, X7
	AND	$7, X12, X8
	BNE	X7, X8, check8_unaligned
	BEQZ	X7, compare32

	// Check one byte at a time until we reach 8 byte alignment.
	SUB	X7, X0, X7
	ADD	$8, X7, X7
	SUB	X7, X5, X5
align:
	SUB	$1, X7
	MOVBU	0(X10), X8

	// X10 = ptr
	// X11 = n

	// If less than 8 bytes, do single byte zeroing.
	MOV	$8, X9
	BLT	X11, X9, check4

	// Check alignment
	AND	$7, X10, X5
	BEQZ	X5, aligned

	// Zero one byte at a time until we reach 8 byte alignment.
	SUB	X5, X9, X5
	SUB	X5, X11, X11
align:
	SUB	$1, X5
	MOVB	ZERO, 0(X10)
	ADD	$1, X10
	BNEZ	X5, align

aligned:
	// X9 already contains $8

		}
	}

	if h.NumField() != rh.NumField() {
		t.Errorf("%v has %d fields, but %v has %d", h, h.NumField(), rh, rh.NumField())
	}
	if h.Align() != rh.Align() {
		t.Errorf("%v has alignment %d, but %v has alignment %d", h, h.Align(), rh, rh.Align())
	}
}

var (
	unsafePointerType = reflect.TypeOf(unsafe.Pointer(nil))
	uintptrType       = reflect.TypeOf(uintptr(0))
)

                    canBeResolved = true
                }
            }

            dependencies {
                constraints {
                    custom(project(":lib")) { because "platform alignment" }
                }
            }

            configurations.custom.copy()
        """
        createDirs("lib")
        settingsFile << "include 'lib'"

        expect:
        succeeds ":help"

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

const (
	maxAlign  = 32 // max data alignment
	minAlign  = 1  // min data alignment
	funcAlign = 16
)

/* Used by ../internal/ld/dwarf.go */
const (
	dwarfRegSP = 1
	dwarfRegLR = 65

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

const (
	maxAlign  = 32 // max data alignment
	minAlign  = 2  // min data alignment
	funcAlign = 16
)

/* Used by ../internal/ld/dwarf.go */
const (
	dwarfRegSP = 15
	dwarfRegLR = 14

// license that can be found in the LICENSE file.

// This test _may_ fail on arm, but requires the host to
// trap unaligned loads. This is generally done with
//
// echo "4" > /proc/cpu/alignment

package main

type T struct {
	U uint16
	V T2
}

type T2 struct {
	pad    [4096]byte
	A, B byte
}

var s, t = new(T), new(T)

func main() {
	var u, v *T2 = &s.V, &t.V