[maleadt]

Draft, not for merging yet. This needs LLVM.jl 10.3 (released) and JuliaIR.jl, which
is not registered yet: the test environment takes its main branch from [sources], and
the commit titled [temp] makes CI work with that; it will be dropped once JuliaIR.jl is
registered.

GPUCompiler's optimization pipeline runs fourteen of the LLVM passes of Julia's code
generator (AllocOpt, LateLowerGCFrame, PropagateJuliaAddrspaces, ...), which only exist
inside Julia's own libLLVM. This lets a compilation take them from
JuliaIR.jl instead, which ports them to Julia, as
the first step towards running GPUCompiler's middle end on a newer LLVM than Julia's.

• CompilerConfig gets a julia_passes field, :cpp (Julia's passes, as today) or :ports.
  Its default comes from the julia_passes preference. It is part of the configuration, so
  cached artifacts are keyed on it; inference caches are not.
• JuliaIR.jl is a weak dependency. Its extension registers the ports and maps each of Julia's
  passes to its port; loading it changes nothing by itself, and selecting :ports without it
  is an error before compilation starts. When the preference selects the ports, loading
  GPUCompiler also loads JuliaIR.jl if the environment provides it, so that packages
  building on GPUCompiler (and their test suites) get the ports without loading it
  themselves.
• The pipeline in optim.jl gets each Julia pass from julia_pass(job, :Name).
• The ports need opaque pointers. On Julia 1.10 and 1.11, reflection then compiles in an
  opaque-pointer context, JuliaContext() creates one when the preference selects the
  ports, and compiling a :ports job in a typed context is an error.
• Precompilation workloads of packages that do not load JuliaIR.jl keep using the C++ passes
  (and cache under that configuration).
• The cached bitcode of runtime functions records whether it uses opaque pointers, and is
  recompiled when read in the other kind of context (on 1.10 and 1.11, reading opaque
  bitcode in a typed context failed; a pre-existing issue that mixing the modes exposes).
• classify_arguments checks that the number of parameters matches the signature, which a
  Type{T} argument not keyed as Core.TypeEgal would silently break.

Tests: test/julia_passes.jl covers the configuration, the providers, the requirements,
loading JuliaIR.jl through the preference, a precompilation workload under the ports
preference, that the ports actually run (JuliaIR.jl's ledger), and a differential: a corpus
of kernels compiled for PTX, GCN, SPIR-V, Metal, native and BPF with both providers must
give identical IR. On 1.10 and 1.11 it also compares typed with opaque pointers using the
C++ passes (unless Julia itself runs with --opaque-pointers). The whole suite passes with
the preference set to either value.

CI on this PR (temporary)

• GitHub Actions: Pkg.test can't resolve the unregistered JuliaIR.jl on Julia 1.10, which
  ignores [sources], so every job sets up test/ (.ci/juliair.jl test) and runs
  test/runtests.jl. The matrix has a julia_passes axis (cpp, ports); the ports jobs
  also check that the preference was applied and that JuliaIR.jl's ledger shows the core
  ports ran. Coverage is not collected meanwhile.
• Buildkite: the back-end steps (CUDA.jl, oneAPI.jl, AMDGPU.jl, Metal.jl, OpenCL.jl) are
  unchanged, and each has a "(ports)" variant that sets the julia_passes = "ports"
  preference, adds JuliaIR.jl to the back-end's test environment, runs its whole test
  suite, and fails unless the ledger shows the ports ran.
• Back-end steps are skipped on draft PRs unless the last commit message selects them:
  [only ports] runs the five ports steps, [only cuda] (etc.) runs both steps of that
  back-end, [only cuda, amdgpu, metal, oneapi, opencl] runs all ten; [skip ports] skips
  the ports steps.

To start the back-end steps on the draft PR, the last pushed commit's message has to carry
the tag, e.g. an empty commit git commit --allow-empty -m "[only ports]" (or
[only cuda, amdgpu, metal, oneapi, opencl] for all ten steps).