Commit dda100f2 authored by K900's avatar K900
Browse files

mesa: split out the Darwin build into a separate expression, heavily clean up Linux 

The way we build Mesa for Linux (and potentially others) is very,
very different from the way we build Mesa on Darwin. In short,
on Linux we generally want to build as much of it as possible,
while on Darwin we want to build just enough of it to get GLX
for legacy X applications.

So, split out the Darwin build into its own expression entirely,
and give it just enough inputs and just enough feature flags to
actually do the one thing we want it to do, and nothing else.

The Linux expression can be simplified further now, but that
would cause rebuilds, so we'll have to do that later.
parent f9723bc4

pkgs/development/libraries/mesa/common.nix

0 → 100644
+32 −0
Original line number Diff line number Diff line 
{ lib, fetchurl }:

rec {

  pname = "mesa";

  version = "24.1.1";



  src = fetchurl {

    urls = [

      "https://archive.mesa3d.org/mesa-${version}.tar.xz"

      "https://mesa.freedesktop.org/archive/mesa-${version}.tar.xz"

    ];

    hash = "sha256-ADiCbG9+iNkLTOb3GRkvpYyn3t9O3KoRdM972SDvieo=";

  };



  meta = {

    description = "Open source 3D graphics library";

    longDescription = ''

      The Mesa project began as an open-source implementation of the OpenGL

      specification - a system for rendering interactive 3D graphics. Over the

      years the project has grown to implement more graphics APIs, including

      OpenGL ES (versions 1, 2, 3), OpenCL, OpenMAX, VDPAU, VA API, XvMC, and

      Vulkan.  A variety of device drivers allows the Mesa libraries to be used

      in many different environments ranging from software emulation to

      complete hardware acceleration for modern GPUs.

    '';

    homepage = "https://www.mesa3d.org/";

    changelog = "https://www.mesa3d.org/relnotes/${version}.html";

    license = with lib.licenses; [ mit ]; # X11 variant, in most files

    platforms = lib.platforms.mesaPlatforms;

    badPlatforms = []; # Load bearing for libGL meta on Darwin.

    maintainers = with lib.maintainers; [ primeos vcunat ]; # Help is welcome :)

  };

}

pkgs/development/libraries/mesa/darwin.nix

0 → 100644
+56 −0
Original line number Diff line number Diff line 
# The Darwin build of Mesa is different enough that we just give it an entire separate expression.

{

  lib,

  stdenv,

  fetchurl,

  bison,

  flex,

  meson,

  ninja,

  pkg-config,

  python3Packages,

  Xplugin,

  xorg,

  zlib,

}:

let

  common = import ./common.nix { inherit lib fetchurl; };

in stdenv.mkDerivation {

  inherit (common) pname version src meta;



  patches = [

    # Reorder things to make it build on Darwin again

    # Submitted upstream: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29592

    # FIXME: remove when merged or otherwise addressed

    ./darwin.patch

  ];



  outputs = [ "out" "dev" ];



  nativeBuildInputs = [

    bison

    flex

    meson

    ninja

    pkg-config

    python3Packages.python

    python3Packages.mako

  ];



  buildInputs = [

    Xplugin

    xorg.libX11

    xorg.libXext

    xorg.libXfixes

    zlib

  ];



  mesonAutoFeatures = "disabled";



  mesonFlags = [

    "--sysconfdir=/etc"

    "--datadir=${placeholder "out"}/share"

    (lib.mesonEnable "glvnd" false)

    (lib.mesonEnable "shared-glapi" true)

  ];

}

pkgs/development/libraries/mesa/default.nix

+90 −236
Original line number Diff line number Diff line 
{ lib

, OpenGL

, Xplugin

, bison

, buildPackages

, directx-headers
@@ -42,19 +40,9 @@ 
, xcbutilkeysyms

, xorg

, zstd

, withValgrind ?

  lib.meta.availableOn stdenv.hostPlatform valgrind-light

  && !valgrind-light.meta.broken

, withLibunwind ? lib.meta.availableOn stdenv.hostPlatform libunwind

, enableGalliumNine ? stdenv.isLinux

, enableOSMesa ? stdenv.isLinux

, enableOpenCL ? stdenv.isLinux && stdenv.isx86_64

, enableTeflon ? stdenv.isLinux && stdenv.isAarch64  # currently only supports aarch64 SoCs, may change in the future

, enablePatentEncumberedCodecs ? true



, galliumDrivers ?

  if stdenv.isLinux

  then [

, galliumDrivers ? [

    "d3d12" # WSL emulated GPU (aka Dozen)

    "iris" # new Intel (Broadwell+)

    "kmsro" # special "render only" driver for GPUs without a display controller
@@ -79,10 +67,7 @@ 
    "crocus" # Intel legacy, x86 only

    "i915" # Intel extra legacy, x86 only

  ]

  else [ "auto" ]

, vulkanDrivers ?

  if stdenv.isLinux

  then [

, vulkanDrivers ? [

    "amd" # AMD (aka RADV)

    "intel" # new Intel (aka ANV)

    "microsoft-experimental" # WSL virtualized GPU (aka DZN/Dozen)
@@ -100,32 +85,19 @@ 
  ] ++ lib.optionals stdenv.hostPlatform.isx86 [

    "intel_hasvk" # Intel Haswell/Broadwell, "legacy" Vulkan driver (https://www.phoronix.com/news/Intel-HasVK-Drop-Dead-Code)

  ]

  else [ "auto" ]

, eglPlatforms ? [ "x11" ] ++ lib.optionals stdenv.isLinux [ "wayland" ]

, vulkanLayers ? lib.optionals (!stdenv.isDarwin) [ # No Vulkan support on Darwin

, eglPlatforms ? [ "x11" "wayland" ]

, vulkanLayers ? [

    "device-select"

    "overlay"

    "intel-nullhw"

  ]

, mesa

}:



# When updating this package, please verify at least these build (assuming x86_64-linux):

# nix build .#mesa .#pkgsi686Linux.mesa .#pkgsCross.aarch64-multiplatform.mesa .#pkgsMusl.mesa



let

  version = "24.1.1";

  hash = "sha256-ADiCbG9+iNkLTOb3GRkvpYyn3t9O3KoRdM972SDvieo=";



  # Release calendar: https://www.mesa3d.org/release-calendar.html

  # Release frequency: https://www.mesa3d.org/releasing.html#schedule

  branch = lib.versions.major version;



  withLibdrm = lib.meta.availableOn stdenv.hostPlatform libdrm;



  haveWayland = lib.elem "wayland" eglPlatforms;

  haveZink = lib.elem "zink" galliumDrivers;

  haveDozen = (lib.elem "d3d12" galliumDrivers) || (lib.elem "microsoft-experimental" vulkanDrivers);



  rustDeps = [

    {

      pname = "paste";
@@ -162,28 +134,13 @@ let 
  copyRustDeps = lib.concatStringsSep "\n" (builtins.map copyRustDep rustDeps);



  needNativeCLC = !stdenv.buildPlatform.canExecute stdenv.hostPlatform;

self = stdenv.mkDerivation {

  pname = "mesa";

  inherit version;



  src = fetchurl {

    urls = [

      "https://archive.mesa3d.org/mesa-${version}.tar.xz"

      "https://mesa.freedesktop.org/archive/mesa-${version}.tar.xz"

      "ftp://ftp.freedesktop.org/pub/mesa/mesa-${version}.tar.xz"

      "ftp://ftp.freedesktop.org/pub/mesa/${version}/mesa-${version}.tar.xz"

      "ftp://ftp.freedesktop.org/pub/mesa/older-versions/${branch}.x/${version}/mesa-${version}.tar.xz"

    ];

    inherit hash;

  };



  common = import ./common.nix { inherit lib fetchurl; };

in stdenv.mkDerivation {

  inherit (common) pname version src meta;



  patches = [

    ./opencl.patch

  ] ++ lib.optionals stdenv.isDarwin [

    # Reorder things to make it build on Darwin again

    # Submitted upstream: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29592

    # FIXME: remove when merged or otherwise addressed

    ./darwin.patch

  ];



  postPatch = ''
@@ -201,16 +158,7 @@ self = stdenv.mkDerivation { 
  '';



  outputs = [

    "out" "dev" "drivers"

  ] ++ lib.optionals enableOSMesa [

    "osmesa"

  ] ++ lib.optionals stdenv.isLinux [

    "driversdev"

  ] ++ lib.optionals enableTeflon [

    "teflon"

  ] ++ lib.optionals enableOpenCL [

    "opencl"

  ] ++ lib.optionals haveDozen [

    "out" "dev" "drivers" "driversdev" "opencl" "teflon" "osmesa"

    # the Dozen drivers depend on libspirv2dxil, but link it statically, and

    # libspirv2dxil itself is pretty chonky, so relocate it to its own output in

    # case anything wants to use it at some point
@@ -228,69 +176,49 @@ self = stdenv.mkDerivation { 


  mesonFlags = [

    "--sysconfdir=/etc"

    "--datadir=${placeholder "drivers"}/share" # Vendor files



    # Don't build in debug mode

    # https://gitlab.freedesktop.org/mesa/mesa/blob/master/docs/meson.html#L327

    (lib.mesonBool "b_ndebug" true)



    (lib.mesonOption "dri-search-path" "${libglvnd.driverLink}/lib/dri")

    "--datadir=${placeholder "drivers"}/share"



    # What to build

    (lib.mesonOption "platforms" (lib.concatStringsSep "," eglPlatforms))

    (lib.mesonOption "gallium-drivers" (lib.concatStringsSep "," galliumDrivers))

    (lib.mesonOption "vulkan-drivers" (lib.concatStringsSep "," vulkanDrivers))

    (lib.mesonOption "vulkan-layers" (builtins.concatStringsSep "," vulkanLayers))



    # Make sure we know where to find all the drivers

    (lib.mesonOption "dri-drivers-path" "${placeholder "drivers"}/lib/dri")

    (lib.mesonOption "vdpau-libs-path" "${placeholder "drivers"}/lib/vdpau")

    (lib.mesonOption "omx-libs-path" "${placeholder "drivers"}/lib/bellagio")

    (lib.mesonOption "va-libs-path" "${placeholder "drivers"}/lib/dri")

    (lib.mesonOption "d3d-drivers-path" "${placeholder "drivers"}/lib/d3d")



    (lib.mesonBool "gallium-nine" enableGalliumNine) # Direct3D in Wine

    (lib.mesonBool "osmesa" enableOSMesa) # used by wine

    (lib.mesonBool "teflon" enableTeflon) # TensorFlow frontend

    (lib.mesonEnable "microsoft-clc" false) # Only relevant on Windows (OpenCL 1.2 API on top of D3D12)



    # To enable non-mesa gbm backends to be found (e.g. Nvidia)

    # Set search paths for non-Mesa drivers (e.g. Nvidia)

    (lib.mesonOption "dri-search-path" "${libglvnd.driverLink}/lib/dri")

    (lib.mesonOption "gbm-backends-path" "${libglvnd.driverLink}/lib/gbm:${placeholder "out"}/lib/gbm")



    # meson auto_features enables these features, but we do not want them

    (lib.mesonEnable "android-libbacktrace" false)

  ] ++ lib.optionals stdenv.isLinux [

    # Enable glvnd for dynamic libGL dispatch

    (lib.mesonEnable "glvnd" true)



    (lib.mesonBool "gallium-nine" true) # Direct3D in Wine

    (lib.mesonBool "osmesa" true) # used by wine

    (lib.mesonBool "teflon" true) # TensorFlow frontend



    # Enable Intel RT stuff when available

    (lib.mesonBool "install-intel-clc" true)

    (lib.mesonEnable "intel-rt" stdenv.isx86_64)

    (lib.mesonOption "clang-libdir" "${llvmPackages.clang-unwrapped.lib}/lib")

  ] ++ lib.optionals stdenv.isDarwin [

    # Disable features that are explicitly unsupported on the platform

    (lib.mesonEnable "gbm" false)

    (lib.mesonEnable "xlib-lease" false)

    (lib.mesonEnable "egl" false)

    (lib.mesonEnable "gallium-vdpau" false)

    (lib.mesonEnable "gallium-va" false)

    (lib.mesonEnable "gallium-xa" false)

    (lib.mesonEnable "lmsensors" false)

    # Don’t build with glvnd support to make sure Mesa builds libGL on Darwin

    (lib.mesonEnable "glvnd" false)

    # This gets enabled by mesonAutoFeatures and fails on aarch64-darwin,

    # which makes no sense because Darwin has neither Intel nor RT, but OK

    (lib.mesonEnable "intel-rt" false)

  ] ++ lib.optionals enableOpenCL [



    # Clover, old OpenCL frontend

    (lib.mesonOption "gallium-opencl" "icd")

    (lib.mesonBool "opencl-spirv" true)



    # Rusticl, new OpenCL frontend

    (lib.mesonBool "gallium-rusticl" true)

  ] ++ lib.optionals (!withValgrind) [

    (lib.mesonEnable "valgrind" false)

  ] ++ lib.optionals (!withLibunwind) [

    (lib.mesonEnable "libunwind" false)

  ]

  ++ lib.optionals enablePatentEncumberedCodecs [



    # meson auto_features enables this, but we do not want it

    (lib.mesonEnable "android-libbacktrace" false)

    (lib.mesonEnable "microsoft-clc" false) # Only relevant on Windows (OpenCL 1.2 API on top of D3D12)

  ] ++ lib.optionals enablePatentEncumberedCodecs [

    (lib.mesonOption "video-codecs" "all")

  ] ++ lib.optionals (vulkanLayers != []) [

    (lib.mesonOption "vulkan-layers" (builtins.concatStringsSep "," vulkanLayers))

  ] ++ lib.optionals needNativeCLC [

    (lib.mesonOption "intel-clc" "system")

  ];
@@ -298,61 +226,45 @@ self = stdenv.mkDerivation { 
  strictDeps = true;



  buildInputs = with xorg; [

    directx-headers

    elfutils

    expat

    glslang

    libffi

    libglvnd

    libomxil-bellagio

    libpthreadstubs

    libunwind

    libva-minimal

    libvdpau

    llvmPackages.libllvm

    openssl

    zstd

  ] ++ (with xorg; [

    libX11

    libxcb

    libXext

    libXfixes

    libXrandr

    libxshmfence

    libXt

    libXvMC

    libpthreadstubs

    libxcb

    libxshmfence

    xcbutilkeysyms

    xorgproto

  ]) ++ lib.optionals withLibunwind [

    libunwind

  ] ++ [

    python3Packages.python # for shebang

  ] ++ lib.optionals haveWayland [

    wayland

    wayland-protocols

  ] ++ lib.optionals stdenv.isLinux [

    libomxil-bellagio

    libva-minimal

    llvmPackages.clang

    llvmPackages.clang-unwrapped

    llvmPackages.libclc

    llvmPackages.libllvm

    lm_sensors

    openssl

    python3Packages.python # for shebang

    spirv-llvm-translator

    udev

  ] ++ lib.optionals (lib.meta.availableOn stdenv.hostPlatform elfutils) [

    elfutils

  ] ++ lib.optionals enableOpenCL [

    llvmPackages.clang

  ] ++ lib.optionals withValgrind [

    valgrind-light

  ] ++ lib.optionals haveZink [

    vulkan-loader

  ] ++ lib.optionals haveDozen [

    directx-headers

    wayland

    wayland-protocols

    xcbutilkeysyms

    xorgproto

    zstd

  ];



  depsBuildBuild = [

    pkg-config

  ] ++ lib.optionals (!stdenv.isDarwin) [

    # Adding this unconditionally makes x86_64-darwin pick up an older

    # toolchain, as we explicitly call Mesa with 11.0 stdenv, but buildPackages

    # is still 10.something, and Mesa can't build with that.

    # FIXME: figure this out, or figure out how to get rid of Mesa on Darwin,

    # whichever is easier.

    buildPackages.stdenv.cc

  ];
@@ -374,7 +286,6 @@ self = stdenv.mkDerivation { 
    rust-bindgen

    rust-cbindgen

    rustPlatform.bindgenHook

  ] ++ lib.optionals haveWayland [

    wayland-scanner

  ] ++ lib.optionals needNativeCLC [

    buildPackages.mesa.driversdev
@@ -384,74 +295,52 @@ self = stdenv.mkDerivation { 
    buildPackages.mesa.driversdev

  ];



  propagatedBuildInputs = (with xorg; [

  propagatedBuildInputs = with xorg; [

    libXdamage

    libXxf86vm

  ]) ++ lib.optionals withLibdrm [

    libdrm

  ] ++ lib.optionals stdenv.isDarwin [

    OpenGL

    Xplugin

  ];



  doCheck = false;



  postInstall = ''

    # Some installs don't have any drivers so this directory is never created.

    mkdir -p $drivers $osmesa

  '' + lib.optionalString stdenv.isLinux ''

    mkdir -p $drivers/lib



    if [ -n "$(shopt -s nullglob; echo "$out/lib/libxatracker"*)" -o -n "$(shopt -s nullglob; echo "$out/lib/libvulkan_"*)" ]; then

      # move gallium-related stuff to $drivers, so $out doesn't depend on LLVM

      mv -t $drivers/lib       \

        $out/lib/libpowervr_rogue* \

        $out/lib/libxatracker* \

        $out/lib/libvulkan_*

    fi

    # Move driver-related bits to $drivers

    moveToOutput "lib/lib*_mesa*" $drivers

    moveToOutput "lib/libpowervr_rogue*" $drivers

    moveToOutput "lib/libxatracker*" $drivers

    moveToOutput "lib/libvulkan_*" $drivers



    if [ -n "$(shopt -s nullglob; echo "$out"/lib/lib*_mesa*)" ]; then

      # Move other drivers to a separate output

      mv -t $drivers/lib $out/lib/lib*_mesa*

    fi



    # Update search path used by glvnd

    # Update search path used by glvnd (it's pointing to $out but drivers are in $drivers)

    for js in $drivers/share/glvnd/egl_vendor.d/*.json; do

      substituteInPlace "$js" --replace '"libEGL_' '"'"$drivers/lib/libEGL_"

      substituteInPlace "$js" --replace-fail '"libEGL_' '"'"$drivers/lib/libEGL_"

    done



    # Update search path used by Vulkan (it's pointing to $out but

    # drivers are in $drivers)

    # And same for Vulkan

    for js in $drivers/share/vulkan/icd.d/*.json; do

      substituteInPlace "$js" --replace "$out" "$drivers"

      substituteInPlace "$js" --replace-fail "$out" "$drivers"

    done

  '' + lib.optionalString enableOpenCL ''

    # Move OpenCL stuff

    mkdir -p $opencl/lib

    mv -t "$opencl/lib/"     \

      $out/lib/gallium-pipe   \

      $out/lib/lib*OpenCL*



    # We construct our own .icd files that contain absolute paths.

    mkdir -p $opencl/etc/OpenCL/vendors/

    echo $opencl/lib/libMesaOpenCL.so > $opencl/etc/OpenCL/vendors/mesa.icd

    echo $opencl/lib/libRusticlOpenCL.so > $opencl/etc/OpenCL/vendors/rusticl.icd

  '' + lib.optionalString enableOSMesa ''

    # move libOSMesa to $osmesa, as it's relatively big

    mkdir -p $osmesa/lib

    mv -t $osmesa/lib/ $out/lib/libOSMesa*

  '' + lib.optionalString (vulkanLayers != []) ''

    mv -t $drivers/lib $out/lib/libVkLayer*



    # Move Vulkan layers to $drivers and update manifests

    moveToOutput "lib/libVkLayer*" $drivers

    for js in $drivers/share/vulkan/{im,ex}plicit_layer.d/*.json; do

      substituteInPlace "$js" --replace '"libVkLayer_' '"'"$drivers/lib/libVkLayer_"

    done

  '' + lib.optionalString haveDozen ''

    mkdir -p $spirv2dxil/{bin,lib}

    mv -t $spirv2dxil/lib $out/lib/libspirv_to_dxil*

    mv -t $spirv2dxil/bin $out/bin/spirv2dxil



    # Construct our own .icd files that contain absolute paths.

    mkdir -p $opencl/etc/OpenCL/vendors/

    echo $opencl/lib/libMesaOpenCL.so > $opencl/etc/OpenCL/vendors/mesa.icd

    echo $opencl/lib/libRusticlOpenCL.so > $opencl/etc/OpenCL/vendors/rusticl.icd



    moveToOutput bin/intel_clc $driversdev

    moveToOutput lib/gallium-pipe $opencl

    moveToOutput "lib/lib*OpenCL*" $opencl

    moveToOutput "lib/libOSMesa*" $osmesa

    moveToOutput bin/spirv2dxil $spirv2dxil

    moveToOutput "lib/libspirv_to_dxil*" $spirv2dxil

    moveToOutput lib/libteflon.so $teflon

  '';



  postFixup = lib.optionalString stdenv.isLinux ''

  postFixup = ''

    # set the default search path for DRI drivers; used e.g. by X server

    for pc in lib/pkgconfig/{dri,d3d}.pc; do

      [ -f "$dev/$pc" ] && substituteInPlace "$dev/$pc" --replace "$drivers" "${libglvnd.driverLink}"
@@ -471,8 +360,6 @@ self = stdenv.mkDerivation { 
      fi

    done



    moveToOutput bin/intel_clc $driversdev



    # Don't depend on build python

    patchShebangs --host --update $out/bin/*
@@ -486,20 +373,12 @@ self = stdenv.mkDerivation { 
        patchelf --set-rpath "$(patchelf --print-rpath $lib):$drivers/lib" "$lib"

      fi

    done



    # add RPATH here so Zink can find libvulkan.so

    ${lib.optionalString haveZink ''

    patchelf --add-rpath ${vulkan-loader}/lib $drivers/lib/dri/zink_dri.so

    ''}



    ${lib.optionalString enableTeflon ''

      moveToOutput lib/libteflon.so $teflon

    ''}

  '';



  env.NIX_CFLAGS_COMPILE = toString (

    lib.optionals stdenv.isDarwin [

      "-fno-common"

    ] ++ lib.optionals enableOpenCL [

  env.NIX_CFLAGS_COMPILE = toString ([

    "-UPIPE_SEARCH_DIR"

    "-DPIPE_SEARCH_DIR=\"${placeholder "opencl"}/lib/gallium-pipe\""

  ]);
@@ -508,37 +387,12 @@ self = stdenv.mkDerivation { 
    inherit (libglvnd) driverLink;

    inherit llvmPackages;



    libdrm = if withLibdrm then libdrm else null;



    tests = lib.optionalAttrs stdenv.isLinux {

      devDoesNotDependOnLLVM = stdenv.mkDerivation {

    tests.devDoesNotDependOnLLVM = stdenv.mkDerivation {

      name = "mesa-dev-does-not-depend-on-llvm";

      buildCommand = ''

          echo ${self.dev} >>$out

        '';

        disallowedRequisites = [ llvmPackages.llvm self.drivers ];

      };

    };

  };



  meta = {

    description = "Open source 3D graphics library";

    longDescription = ''

      The Mesa project began as an open-source implementation of the OpenGL

      specification - a system for rendering interactive 3D graphics. Over the

      years the project has grown to implement more graphics APIs, including

      OpenGL ES (versions 1, 2, 3), OpenCL, OpenMAX, VDPAU, VA API, XvMC, and

      Vulkan.  A variety of device drivers allows the Mesa libraries to be used

      in many different environments ranging from software emulation to

      complete hardware acceleration for modern GPUs.

        echo ${mesa.dev} >>$out

      '';

    homepage = "https://www.mesa3d.org/";

    changelog = "https://www.mesa3d.org/relnotes/${version}.html";

    license = with lib.licenses; [ mit ]; # X11 variant, in most files

    platforms = lib.platforms.mesaPlatforms;

    badPlatforms = []; # Load bearing for libGL meta on Darwin.

    maintainers = with lib.maintainers; [ primeos vcunat ]; # Help is welcome :)

      disallowedRequisites = [ llvmPackages.llvm mesa.drivers ];

    };

  };



in self
 
}

pkgs/top-level/all-packages.nix

+6 −4
Original line number Diff line number Diff line
@@ -23264,10 +23264,12 @@ with pkgs; 
  # Default libGLU

  libGLU = mesa_glu;













  mesa = darwin.apple_sdk_11_0.callPackage ../development/libraries/mesa {













    inherit (darwin.apple_sdk_11_0.frameworks) OpenGL;













  mesa = if stdenv.isDarwin













    then darwin.apple_sdk_11_0.callPackage ../development/libraries/mesa/darwin.nix {















      inherit (darwin.apple_sdk_11_0.libs) Xplugin;













  };













    }













    else callPackage ../development/libraries/mesa {};



























  mesa_i686 = pkgsi686Linux.mesa; # make it build on Hydra





























  mesa_glu =  callPackage ../development/libraries/mesa-glu {