// CHECK-LOC: @init_func_init_op
// CHECK-LOC: return
}

// -----

// Test that `RestoreV2Op` is created even when the `Const` op is shared across
// `AssignVariableOp`s.

module attributes {tf_saved_model.semantics} {
  "tf_saved_model.session_initializer"() {initializers = [@init_func_restore_op_multiple_variables_sharing_const]} : () -> ()

                outputDir = project.layout.buildDirectory.dir("shared-output")
            }
            def producerUntracked = tasks.register("producerUntracked", UntrackedProducer) {
                outputDir = project.layout.buildDirectory.dir("shared-output")
                mustRunAfter(producerTracked)
            }
            tasks.register("consumer", Consumer) {

	}
}

func archRISCV64(shared bool) *Arch {
	register := make(map[string]int16)

	// Standard register names.
	for i := riscv.REG_X0; i <= riscv.REG_X31; i++ {
		// Disallow X3 in shared mode, as this will likely be used as the
		// GP register, which could result in problems in non-Go code,
		// including signal handlers.
		if shared && i == riscv.REG_GP {
			continue
		}

        project.pluginManager.apply(SwiftPackageManagerExportPlugin)

        lib1Project.pluginManager.apply("cpp-library")
        lib1Project.library.linkage = [Linkage.SHARED, Linkage.STATIC]

        project.evaluate()

        expect:
        def generateManifest = project.tasks['generateSwiftPmManifest']
        def targets = generateManifest.package.get().targets

    "path": "platforms/jvm/toolchains-jvm",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": true
  },
  {
    "name": "toolchains-jvm-shared",
    "path": "platforms/jvm/toolchains-jvm-shared",
    "unitTests": true,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "tooling-api",
    "path": "platforms/ide/tooling-api",

        return service.launcherFor(extension.getToolchain());
    }

    /**
     * A state shared by the validation process.
     * <p>
     * This separate class is required to ensure the shared state remains shared after deserialization of actions from the configuration cache.
     *
     * @see #configureJarTask(Project, GradlePluginDevelopmentExtension)
     */

	{82, "EREMCHG", "remote address changed"},
	{83, "ELIBACC", "can not access a needed shared library"},
	{84, "ELIBBAD", "accessing a corrupted shared library"},
	{85, "ELIBSCN", ".lib section in a.out corrupted"},
	{86, "ELIBMAX", "attempting to link in too many shared libraries"},
	{87, "ELIBEXEC", "cannot exec a shared library directly"},
	{88, "EILSEQ", "invalid or incomplete multibyte or wide character"},

 * `linkDebug` and `linkRelease` tasks that link the compiled {cpp} object files into an executable for applications or shared library for libraries with shared linkage for the debug and release build types.

	t.Logf("%v\n%s", argv, out)
	if err != nil {
		t.Fatal(err)
	}
}

// TestCompileWithoutShared tests that if we compile code without the
// -shared option, we can put it into an archive. When we use the go
// tool with -buildmode=c-archive, it passes -shared to the compiler,
// so we override that. The go tool doesn't work this way, but Bazel
// will likely do it in the future. And it ought to work. This test

	// We assume the informer is already started, and starts all types associated
	// with it.
	if genericInformer, err := s.informerFactory.ForResource(mapping.Resource); err == nil {
		informer = genericInformer

		// Start the informer
		s.informerFactory.Start(instanceContext.Done())

	} else {
		// Dynamic JSON informer fallback.
		// Cannot use shared dynamic informer since it would be impossible