"""

        when:
        succeeds("test")

        then:
        result.assertTasksExecuted(tasks.debug.compile, tasks.test.relocate, tasks.test.allToInstall, ":xcTest", ":test")
        result.assertTasksSkipped(tasks.debug.compile, tasks.test.relocate, tasks.test.allToInstall, ":xcTest", ":test")
    }

    @ToBeFixedForConfigurationCache

In order to determine the classes to relocate, it looks at the packages of the input artifact and the dependencies of the input artifact.
It also does not relocate packages contained in JAR files in an external classpath.

.Artifact transform for class relocation
====
include::sample[dir="snippets/dependencyManagement/artifactTransforms-relocate/kotlin",files="build.gradle.kts[tags=artifact-transform-relocate]"]

                        if (literal == null) {
                            // tries to relocate literals in the form of foo/bar/Bar
                            literal = remapper.maybeRelocateResource((String) cst);
                        }
                        if (literal == null) {
                            // tries to relocate literals in the form of foo.bar.Bar

        write(ImmutableList.of(sourceLocation, targetLocation), () -> {
            Files.move(Paths.get(sourceLocation), Paths.get(targetLocation), ATOMIC_MOVE);
            sourceSnapshot.relocate(targetLocation, stringInterner)
                .ifPresent(this::record);
        });
    }

    @Override
    public void onDefaultExcludesChanged(List<String> excludes) {

  Block& save_func_body = src_graph_op.GetBody();
  for (Operation& op : save_func_body.without_terminator()) {
    main_body.push_back(op.clone(mapper));
  }

  // Relocate the main function's FetchOp to the last.
  main_body.push_back(main_fetch_op->clone(mapper));
  main_fetch_op.erase();

  auto cloned_fetch_op = cast<FetchOp>(src_graph_op.GetFetch()->clone(mapper));

  Block& main_body = main_graph_op.GetBody();
  Block& src_body = src_graph_op.GetBody();
  for (Operation& op : src_body.without_terminator()) {
    main_body.push_back(op.clone(mapper));
  }

  // Relocate the main function's FetchOp at the last.
  main_body.push_back(main_fetch_op->clone(mapper));

  // Clone the source's FetchOp, but do not push to the main function's body.

// frame being asked about.
//
// The result of getcallersp is correct at the time of the return,
// but it may be invalidated by any subsequent call to a function
// that might relocate the stack in order to grow or shrink it.
// A general rule is that the result of getcallersp should be used
// immediately and can only be passed to nosplit functions.

//go:noescape
func getcallerpc() uintptr

		size += ldr.SymSize(s7)
	}

	return Rnd(size, *FlagRound)
}

func machorelocsect(ctxt *Link, out *OutBuf, sect *sym.Section, syms []loader.Sym) {
	// If main section has no bits, nothing to relocate.
	if sect.Vaddr >= sect.Seg.Vaddr+sect.Seg.Filelen {
		return
	}
	ldr := ctxt.loader

	for i, s := range syms {
		if !ldr.AttrReachable(s) {
			continue
		}

func round2(x int32) int32 {
	s := uint(0)
	for 1<<s < x {
		s++
	}
	return 1 << s
}

// Called from runtime·morestack when more stack is needed.
// Allocate larger stack and relocate to new stack.
// Stack growth is multiplicative, for constant amortized cost.
//
// g->atomicstatus will be Grunning or Gscanrunning upon entry.
// If the scheduler is trying to stop this g, then it will set preemptStop.

	// liblink and then finally using relocations in the linker.
	//
	// When -shared is passed, we leave the code in the 2-instruction form but
	// assemble (and relocate) them in different ways to generate the initial
	// exec code sequence. It's a bit of a fluke that this is possible without
	// rewriting the instructions more comprehensively, and it only does because