atomic.AddUint32(&ldr.SymSect(s).Relcount, uint32(nExtReloc))
	}
}

// Convert a Go relocation to an external relocation.
func extreloc(ctxt *Link, ldr *loader.Loader, s loader.Sym, r loader.Reloc) (loader.ExtReloc, bool) {
	var rr loader.ExtReloc
	target := &ctxt.Target
	siz := int32(r.Siz())
	if siz == 0 { // informational relocation - no work to do
		return rr, false
	}

	rt := r.Type()

	dateFormat = "2006-01-02"
	// TODO(rfindley): use dateFormat throughout.
)

// uploadReportDate returns the date component of the upload file name, or "" if the
// date was unmatched.
func (u *uploader) uploadReportDate(fname string) time.Time {
	match := dateRE.FindStringSubmatch(fname)
	if match == nil || len(match) < 2 {
		u.logger.Printf("malformed report name: missing date: %q", filepath.Base(fname))
		return time.Time{}

func (d *deadcodePass) decodeGenericIfaceMethod(ldr *loader.Loader, symIdx loader.Sym) string {
	return ldr.DataString(symIdx)
}

func (d *deadcodePass) decodetypeMethods(ldr *loader.Loader, arch *sys.Arch, symIdx loader.Sym, relocs *loader.Relocs) []methodsig {
	p := ldr.Data(symIdx)
	if !decodetypeHasUncommon(arch, p) {

    private static final Loader SKIP_INSTRUMENTATION = new Loader();
    private final ConcurrentMap<ProtectionDomain, Loader> loaders;
    private final TransformedClassPath classPath;
    private volatile boolean closed;

    public TransformReplacer(TransformedClassPath classPath) {
        this.loaders = new ConcurrentHashMap<ProtectionDomain, Loader>();
        this.classPath = classPath;
    }

    /**

  """Wraps RegisterCustomOpdefs with lazy loader."""
  return _pywrap_converter_api.RegisterCustomOpdefs(custom_opdefs_list)


def wrapped_retrieve_collected_errors():
  """Wraps RetrieveCollectedErrors with lazy loader."""
  return _pywrap_converter_api.RetrieveCollectedErrors()


def wrapped_flat_buffer_file_to_mlir(model, input_is_filepath):
  """Wraps FlatBufferFileToMlir with lazy loader."""

    @Nullable
    @Override
    public byte[] transform(
        @Nullable ClassLoader loader,
        @Nullable String className,
        @Nullable Class<?> classBeingRedefined,
        @Nullable ProtectionDomain protectionDomain,
        byte[] classfileBuffer
    ) {
        if (!(loader instanceof InstrumentingClassLoader)) {
            return null;
        }

    }

    /**
     * TODO (KT-68186): This is a workaround for [KT-68186](https://youtrack.jetbrains.com/issue/KT-68186). We cannot rely on the
     * application's class loader for now, so we have to use the configured class loader manually.
     */
    fun registerApplicationServices(application: MockApplication, pluginRelativePath: String, classLoader: ClassLoader) {
        registerServices(
            application,

package configstore

import (
	"os/exec"
	"syscall"

	"golang.org/x/sys/windows"
)

func init() {
	needNoConsole = needNoConsoleWindows
}

func needNoConsoleWindows(cmd *exec.Cmd) {
	// The uploader main process is likely a daemonized process with no console.
	// (see x/telemetry/start_windows.go) The console creation behavior when
	// a parent is a console process without console is not clearly documented

    private val cache: BuildTreeConfigurationCache
) : BuildTreeWorkGraphPreparer {
    override fun prepareToScheduleTasks(workGraph: BuildTreeWorkGraph.Builder) {
        if (!cache.isLoaded) {
            delegate.prepareToScheduleTasks(workGraph)
        } // else, not required
    }

// This file contains the module-mode package loader, as well as some accessory
// functions pertaining to the package import graph.
//
// There are two exported entry points into package loading — LoadPackages and
// ImportFromFiles — both implemented in terms of loadFromRoots, which itself
// manipulates an instance of the loader struct.
//
// Although most of the loading state is maintained in the loader struct,