// Lowering loads
(Load <t> ptr mem) && (is64BitInt(t) || isPtr(t)) => (MOVDload ptr mem)
(Load <t> ptr mem) && is32BitInt(t) &&  t.IsSigned() => (MOVWload ptr mem)
(Load <t> ptr mem) && is32BitInt(t) && !t.IsSigned() => (MOVWZload ptr mem)
(Load <t> ptr mem) && is16BitInt(t) &&  t.IsSigned() => (MOVHload ptr mem)
(Load <t> ptr mem) && is16BitInt(t) && !t.IsSigned() => (MOVHZload ptr mem)

	any := true
	for any {
		var load []uint64
		returnAllUndefs := -1
		undefs, froms := ctxt.loader.UndefinedRelocTargets(returnAllUndefs)
		if buildcfg.GOOS == "windows" {
			undefs, froms = pruneUndefsForWindows(ctxt.loader, undefs, froms)
		}
		for k, symIdx := range undefs {
			sname := ctxt.loader.SymName(symIdx)
			if off := armap[sname]; off != 0 && !loaded[off] {
				load = append(load, off)
				loaded[off] = true

                cacheAction == LOAD && !hasProblems -> log("Configuration cache entry reused.")
                cacheAction == LOAD -> log("Configuration cache entry reused with {}.", problemCountString)
                hasTooManyProblems -> log("Too many configuration cache problems found ({}).", problemCountString)

package org.jetbrains.kotlin.analysis.api.impl.base.java.source

import com.intellij.psi.*
import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory
import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementTypeSource

internal abstract class JavaElementDelegatingTypeSourceWithSmartPointer<PSI : PsiElement, TYPE : PsiType> : JavaElementTypeSource<TYPE>() {
    abstract val psiPointer: SmartPsiElementPointer<out PSI>

            } catch (e: InvocationTargetException) {
                // unwrap ITEs as they are not useful to users
                throw GradleException("Could not load the value of $trace.", e.cause)
            } catch (e: Exception) {
                throw GradleException("Could not load the value of $trace.", e)
            }
        action(value)
    }

#                            |-> example.com/q v1.0.5 -> example.com/r v1.0.0
# If we didn't load the whole graph and didn't load the dependencies of b
# when loading p, we would end up loading q v1.0.0, rather than v1.1.0,
# which is selected by MVS.

go list -m all
stdout 'example.com/w v1.0.0'
stdout 'example.com/q v1.1.0'
stdout 'example.com/z v1.1.0'
stdout 'example.com/x v1.0.0'

		{name: "FMOVDload", argLength: 2, reg: fpload, aux: "SymOff", asm: "FMOVD", typ: "Float64", faultOnNilArg0: true, symEffect: "Read"},  // load from arg0 + auxInt + aux.  arg1=mem.

		// register indexed load
		{name: "MOVDloadidx", argLength: 3, reg: gp2load, asm: "MOVD", typ: "UInt64"},    // load 64-bit dword from arg0 + arg1, arg2 = mem.

        return writeOperation(p -> p.merge(key, value, remappingFunction));
    }

    @Override
    public synchronized void load(Reader reader) throws IOException {
        try {
            writeOperationVoid(p -> {
                try {
                    p.load(reader);
                } catch (IOException e) {
                    throw new IOError(e);
                }
            });

import org.jetbrains.kotlin.asJava.classes.annotateByKotlinType
import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
import org.jetbrains.kotlin.load.kotlin.getOptimalModeForReturnType
import org.jetbrains.kotlin.load.kotlin.getOptimalModeForValueParameter
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.platform.has

go work edit -go=1.21
grep '^go 1.21$' go.work
! grep toolchain go.work
env GOTOOLCHAIN=local
! go work sync
stderr '^go: cannot load module m1_22_0 listed in go.work file: m1_22_0'${/}'go.mod requires go >= 1.22.0 \(running go 1.21; GOTOOLCHAIN=local\)$'
stderr '^go: cannot load module m1_22_1 listed in go.work file: m1_22_1'${/}'go.mod requires go >= 1.22.1 \(running go 1.21; GOTOOLCHAIN=local\)$'
env GOTOOLCHAIN=auto
go work sync