// R9 = addr of target function
TEXT	racecallatomic<>(SB), NOSPLIT, $0
	// Set up these registers
	// R0 = *ThreadState
	// R1 = caller pc
	// R2 = pc
	// R3 = addr of incoming arg list

	// Trigger SIGSEGV early.
	MOVD	40(RSP), R3	// 1st arg is addr. after two times BL, get it at 40(RSP)
	MOVB	(R3), R13	// segv here if addr is bad
	// Check that addr is within [arenastart, arenaend) or within [racedatastart, racedataend).

Manual testing has its place in the development process, but it is not a replacement for automated testing.

== Setting up automated tests

Setting up a suite of tests early on is crucial to the success of your plugin.
Automated tests become an invaluable safety net when upgrading the plugin to a new Gradle version or enhancing/refactoring the code.

=== Organizing test source code

	MOVQ		p_len+16(FP), numBytes		// get number of input bytes to hash
	SHRQ		$6, numBytes			// force modulo 64 input buffer length
	SHLQ		$6, numBytes
	CMPQ		numBytes, $0			// exit early for zero-length input buffer
	JEQ		done
	ADDQ		dataPtr, numBytes		// point numBytes to end of input buffer
	VMOVDQU		(0*16)(digestPtr), state0	// load initial hash values and reorder

// See the License for the specific language governing permissions and
// limitations under the License.

[[working_with_files]]
= Working With Files

File operations are fundamental to nearly every Gradle build.
They involve handling source files, managing file dependencies, and generating reports.
Gradle provides a robust API that simplifies these operations, enabling developers to perform necessary file tasks easily.

[[config_cache:stable]]
== Stable configuration cache

Working towards the stabilization of configuration caching we implemented some strictness behind a feature flag when it was considered too disruptive for early adopters.

You can enable that feature flag as follows:

====
include::sample[dir="snippets/configurationCache/stableFeatureFlag/kotlin",files="settings.gradle.kts[]"]

cmp64:	// >= 64B
	DCBT	(R5)		// optimize for size>=64
	DCBT	(R6)		// cache hint

	SRD	$6,R9,R14	// There is at least one iteration.
	MOVD	R14,CTR
	ANDCC   $63,R9,R9
	CMP	R9,$16,CR1	// Do setup for tail check early on.
	CMP	R9,$32,CR2
	CMP	R9,$48,CR3
	ADD	$-16,R9,R9

	MOVD	$32,R11		// set offsets to load into vector
	MOVD	$48,R12		// set offsets to load into vector

	PCALIGN	$16
cmp64_loop:

- <<variant_model.adoc#understanding-variant-selection,variant-aware resolution>>

Publication of Gradle Module Metadata will enable better dependency management for your consumers:

- early discovery of problems by detecting <<component_capabilities.adoc#declaring-component-capabilities,incompatible modules>>

Task ordering can be useful in a number of scenarios:

* Enforce sequential ordering of tasks (e.g., `build` never runs before `clean`).
* Run build validations early in the build (e.g., validate I have the correct credentials before starting the work for a release build).

Another common step is to attach all the unit test dependencies to the integration tests as well — via `intTestImplementation.extendsFrom testImplementation` — but that only makes sense if the integration tests require _all_ or nearly all the same dependencies that the unit tests have.

There are a couple of other facets of the example you should take note of:

Alternatively, you might want to enable verification on CI servers but not on local machines.

Gradle actually provides 3 different verification modes:

- `strict`, which is the default.
Verification fails _as early as possible_, in order to avoid the use of compromised dependencies during the build.
- `lenient`, which will run the build even if there are verification failures.