func MSanWrite(addr unsafe.Pointer, len int) {
	msanwrite(addr, uintptr(len))
}

// Private interface for the runtime.
const msanenabled = true

// If we are running on the system stack, the C program may have
// marked part of that stack as uninitialized. We don't instrument
// the runtime, but operations like a slice copy can call msanread
// anyhow for values on the stack. Just ignore msanread when running

Status ImmediateExecutionTensorHandle::SummarizeValue(
    std::string& summary) const {
  Status status;
  AbstractTensorPtr resolved(
      // TODO(allenl): Resolve should be const, and the caches that get updated
      // marked mutable.
      const_cast<ImmediateExecutionTensorHandle*>(this)->Resolve(&status));
  if (!status.ok()) {
    return status;
  }
  summary = resolved->SummarizeValue();
  return absl::OkStatus();
}

<!-- go.dev/issue/67401, CL 585556, CL 587220, and many more -->
The linker now disallows using a `//go:linkname` directive to refer to
internal symbols in the standard library (including the runtime) that
are not marked with `//go:linkname` on their definitions.
Similarly, the linker disallows references to such symbols from assembly
code.
For backward compatibility, existing usages of `//go:linkname` found in

 *
 * <p>This annotation replaces {@literal @}{@link groovy.test.NotYetImplemented}.
 * The problem with {@code NotYetImplemented} is that it succeeds no matter what causes the marked test
 * to fail. Tests like that can pass because the expected failure is still present, or even if the
 * expected failure is replaced by some other failure. It's better to write a test that explicitly

# on rsc.io/sampler, and an indirect requirement on golang.org/x/text
# through rsc.io/isampler. Module example.com/b has a direct
# requirement on example.com/c which is incorrectly marked as indirect
# in module example.com/b's go.mod file.

# Check that go list -m processes the indirect annotations in the
# go.mod file.
go list -f '{{.Path}} {{.Indirect}}' -m all
stdout 'example.com/a false'

	g *g

	// timer is the timer used for the scavenger to sleep.
	timer *timer

	// sysmonWake signals to sysmon that it should wake the scavenger.
	sysmonWake atomic.Uint32

	// parked is whether or not the scavenger is parked.
	parked bool

	// printControllerReset instructs printScavTrace to signal that
	// the controller was reset.
	printControllerReset bool

  }) {allow_soft_placement = true, num_cores_per_replica = 1, topology =  "", device_assignment =  []} : () -> tensor<i32>
  func.return %0 : tensor<i32>
}

// Test that operations inside tf.IfRegion op are corrected marked for outside
// compilation.

// CHECK-LABEL: func @ops_inside_tf_if_outside_compiled
func.func @ops_inside_tf_if_outside_compiled(%arg0: tensor<i1>, %arg1: tensor<!tf_type.string>) -> tensor<f32> {

           &mark_for_compilation_flags->tf_xla_min_cluster_size,
           "Minimum number of operators in an XLA compilation. Ignored for "
           "operators placed on an XLA device or operators explicitly marked "
           "for compilation."),
      Flag("tf_xla_max_cluster_size",
           &mark_for_compilation_flags->tf_xla_max_cluster_size,
           "Maximum number of operators in an XLA compilation."),
      Flag(

        run "javadoc"
        then:
        executedAndNotSkipped(":javadoc")

        when: "running the task the second time after adding a custom option, it is executed and succeeds and NOT marked UP-TO-DATE"
        buildFile.text = """
            task javadoc(type: Javadoc) {
                destinationDir = file("build/javadoc")
                source "src/main/java"
                options {

	// funcs records the back-edges of the BFS call graph walk. It
	// maps from the ODCLFUNC of each function that must not have
	// write barriers to the call that inhibits them. Functions
	// that are directly marked go:nowritebarrierrec are in this
	// map with a zero-valued nowritebarrierrecCall. This also
	// acts as the set of marks for the BFS of the call graph.
	funcs := make(map[*ir.Func]nowritebarrierrecCall)