// If not set, a default mapper will be used.
  tensorflow::OpOrArgNameMapper* op_or_arg_name_mapper = nullptr;
  // User-specified value of flatbuffer alignment requirement for custom
  // options. If specified, the value should be multiplier of 16 (default
  // alignment for TFL flatbuffer).
  std::optional<size_t> custom_option_alignment = std::nullopt;
};

// Translates the given MLIR `module` into a FlatBuffer and stores the

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

//go:build !goexperiment.staticlockranking

package sync

import "unsafe"

// Approximation of notifyList in runtime/sema.go. Size and alignment must
// agree.
type notifyList struct {
	wait   uint32
	notify uint32
	lock   uintptr // key field of the mutex
	head   unsafe.Pointer
	tail   unsafe.Pointer

//go:build wasm

package cpu

// We're compiling the cpu package for an unknown (software-abstracted) CPU.
// Make CacheLinePad an empty struct and hope that the usual struct alignment
// rules are good enough.

const cacheLineSize = 0

func initOptions() {}

	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"