uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>
This commit is contained in:
Anton Arapov 2021-04-03 12:58:10 +02:00 committed by Alan Daniels
commit 56de2bcd43
30691 changed files with 3076956 additions and 0 deletions

View file

@ -0,0 +1,111 @@
{ lib, vscode-utils
, fetchurl, mono, writeScript, runtimeShell
, jq, clang-tools
, gdbUseFixed ? true, gdb # The gdb default setting will be fixed to specified. Use version from `PATH` otherwise.
}:
/*
Note that this version of the extension still has some nix specific issues
which could not be fixed merely by patching (inside a C# dll).
In particular, the debugger requires either gnome-terminal or xterm. However
instead of looking for the terminal executable in `PATH`, for any linux platform
the dll uses an hardcoded path to one of these.
So, in order for debugging to work properly, you merely need to create symlinks
to one of these terminals at the appropriate location.
The good news is the the utility library is open source and with some effort
we could build a patched version ourselves. See:
<https://github.com/Microsoft/MIEngine/blob/2885386dc7f35e0f1e44827269341e786361f28e/src/MICore/TerminalLauncher.cs#L156>
Also, the extension should eventually no longer require an external terminal. See:
<https://github.com/Microsoft/vscode-cpptools/issues/35>
Once the symbolic link temporary solution taken, everything shoud run smootly.
*/
let
gdbDefaultsTo = if gdbUseFixed then "${gdb}/bin/gdb" else "gdb";
openDebugAD7Script = writeScript "OpenDebugAD7" ''
#!${runtimeShell}
BIN_DIR="$(cd "$(dirname "$0")" && pwd -P)"
${if gdbUseFixed
then ''
export PATH=''${PATH}''${PATH:+:}${gdb}/bin
''
else ""}
${mono}/bin/mono $BIN_DIR/bin/OpenDebugAD7.exe $*
'';
in
vscode-utils.buildVscodeMarketplaceExtension rec {
mktplcRef = {
name = "cpptools";
publisher = "ms-vscode";
version = "1.9.1";
};
vsix = fetchurl {
name = "${mktplcRef.publisher}-${mktplcRef.name}.gz";
url = "https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${mktplcRef.publisher}/vsextensions/${mktplcRef.name}/${mktplcRef.version}/vspackage?targetPlatform=linux-x64";
sha256 = "sha256-BtTl9DR8hnwNpO5k99M4dtqcTQ2hTzVbjR8VZh+tdDI=";
};
unpackPhase = ''
runHook preUnpack
gzip -d $src --stdout &> temporary.zip
unzip temporary.zip
rm temporary.zip
cd extension/
runHook postUnpack
'';
buildInputs = [
jq
];
postPatch = ''
mv ./package.json ./package_orig.json
# 1. Add activation events so that the extension is functional. This listing is empty when unpacking the extension but is filled at runtime.
# 2. Patch `package.json` so that nix's *gdb* is used as default value for `miDebuggerPath`.
cat ./package_orig.json | \
jq --slurpfile actEvts ${./package-activation-events.json} '(.activationEvents) = $actEvts[0]' | \
jq '(.contributes.debuggers[].configurationAttributes | .attach , .launch | .properties.miDebuggerPath | select(. != null) | select(.default == "/usr/bin/gdb") | .default) = "${gdbDefaultsTo}"' > \
./package.json
# Prevent download/install of extensions
touch "./install.lock"
# Mono runtimes from nix package (used by generated `OpenDebugAD7`).
mv ./debugAdapters/bin/OpenDebugAD7 ./debugAdapters/bin/OpenDebugAD7_orig
cp -p "${openDebugAD7Script}" "./debugAdapters/bin/OpenDebugAD7"
# Clang-format from nix package.
mv ./LLVM/ ./LLVM_orig
mkdir "./LLVM/"
find "${clang-tools}" -mindepth 1 -maxdepth 1 | xargs ln -s -t "./LLVM"
# Patching cpptools and cpptools-srv
elfInterpreter="$(cat $NIX_CC/nix-support/dynamic-linker)"
patchelf --set-interpreter "$elfInterpreter" ./bin/cpptools
patchelf --set-interpreter "$elfInterpreter" ./bin/cpptools-srv
chmod a+x ./bin/cpptools{-srv,}
'';
meta = with lib; {
license = licenses.unfree;
maintainers = [ maintainers.jraygauthier ];
# A 32 bit linux would also be possible with some effort (specific download of binaries +
# patching of the elf files with 32 bit interpreter).
platforms = [ "x86_64-linux" ];
};
}

View file

@ -0,0 +1,51 @@
#!/usr/bin/env nix-shell
#! nix-shell -p coreutils -i bash
scriptDir=$(cd "`dirname "$0"`"; pwd)
echo "scriptDir='$scriptDir'"
function get_pkg_out() {
local pkg="$1"
local suffix="${2:-}"
local nixExp="with (import <nixpkgs> {}); ${pkg}"
echo "$(nix-build -E "$nixExp" --no-out-link)${suffix}"
}
interpreter="$(get_pkg_out "stdenv.cc.libc" "/lib/ld-linux-x86-64.so.2")"
echo "interpreter='$interpreter'"
# For clangformat dep on 'libtinfo.so.5'.
ncursesLibDir="$(get_pkg_out "ncurses5.out" "/lib")"
echo "ncursesLibDir='$ncursesLibDir'"
# For clanformat dep on 'libstdc++.so.6'.
stdcppLibDir="$(get_pkg_out "stdenv.cc.cc.lib" "/lib")"
echo "stdcppLibDir='$stdcppLibDir'"
# For clangformat dep on 'libz.so.1'.
zlibLibDir="$(get_pkg_out "zlib.out" "/lib")"
echo "zlibLibDir='$zlibLibDir'"
function patchelf_mono() {
local exe="$1"
patchelf --set-interpreter "$interpreter" "$exe"
}
function patchelf_clangformat() {
local exe="$1"
patchelf --set-interpreter "$interpreter" "$exe"
local rpath="$ncursesLibDir:$stdcppLibDir:$zlibLibDir"
patchelf --set-rpath "$rpath" "$exe"
}
function print_nix_version_clangtools() {
nixClangToolsBin="$(get_pkg_out "clang-tools" "/bin")"
echo "nixClangToolsBin='$nixClangToolsBin'"
$nixClangToolsBin/clang-format --version
}
function print_nix_version_mono() {
nixMonoBin="$(get_pkg_out "mono" "/bin")"
echo "nixMonoBin='$nixMonoBin'"
$nixMonoBin/mono --version
}

View file

@ -0,0 +1,25 @@
[
"onLanguage:cpp",
"onLanguage:c",
"onCommand:extension.pickNativeProcess",
"onCommand:extension.pickRemoteNativeProcess",
"onCommand:C_Cpp.ConfigurationEdit",
"onCommand:C_Cpp.ConfigurationSelect",
"onCommand:C_Cpp.ConfigurationProviderSelect",
"onCommand:C_Cpp.SwitchHeaderSource",
"onCommand:C_Cpp.Navigate",
"onCommand:C_Cpp.GoToDeclaration",
"onCommand:C_Cpp.PeekDeclaration",
"onCommand:C_Cpp.ToggleErrorSquiggles",
"onCommand:C_Cpp.ToggleIncludeFallback",
"onCommand:C_Cpp.ToggleDimInactiveRegions",
"onCommand:C_Cpp.ToggleSnippets",
"onCommand:C_Cpp.ShowReleaseNotes",
"onCommand:C_Cpp.ResetDatabase",
"onCommand:C_Cpp.PauseParsing",
"onCommand:C_Cpp.ResumeParsing",
"onCommand:C_Cpp.ShowParsingCommands",
"onCommand:C_Cpp.TakeSurvey",
"onDebug",
"workspaceContains:/.vscode/c_cpp_properties.json"
]

View file

@ -0,0 +1,168 @@
#!/usr/bin/env nix-shell
#! nix-shell -p coreutils -p jq -p unzip -i bash
set -euo pipefail
#
# A little script to help maintaining this package. It will:
#
# - download the specified version of the extension to the store and print its url, packed store path and hash
# - unpack the extension, bring it to the store and print its store path and hash
# - fetch its runtimes dependencies from the 'package.json' file using the 'jq' utility, unpack those to the store
# and print its url store path and hash
# - patch elf of the binaries that got a nix replacement
# - bring the patched version to the store
# - run their '--version' and call 'ldd'
# - print the version of the runtime deps nix replacements.
#
# TODO: Print to a properly formated nix file all the required information to fetch everything (extension + runtime deps).
# TODO: Print x86 and maybe darwin runtime dependencies.
#
scriptDir=$(cd "`dirname "$0"`"; pwd)
echo "scriptDir='$scriptDir'"
extPublisher="vscode"
extName="cpptools"
defaultExtVersion="0.16.1"
extVersion="${1:-$defaultExtVersion}"
echo
echo "------------- Downloading extension ---------------"
extZipStoreName="${extPublisher}-${extName}.zip"
extUrl="https://ms-vscode.gallery.vsassets.io/_apis/public/gallery/publisher/ms-vscode/extension/cpptools/${extVersion}/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage"
echo "extUrl='$extUrl'"
storePathWithSha=$(nix-prefetch-url --name "$extZipStoreName" --print-path "$extUrl" 2> /dev/null)
cpptoolsZipStorePath="$(echo "$storePathWithSha" | tail -n1)"
cpptoolsZipSha256="$(echo "$storePathWithSha" | head -n1)"
echo "cpptoolsZipStorePath='$cpptoolsZipStorePath'"
echo "cpptoolsZipSha256='$cpptoolsZipSha256'"
extStoreName="${extPublisher}-${extName}"
function rm_tmpdir() {
#echo "Removing \`tmpDir='$tmpDir'\`"
rm -rf -- "$tmpDir"
unset tmpDir
trap - INT TERM HUP EXIT
}
function make_trapped_tmpdir() {
tmpDir=$(mktemp -d)
trap rm_tmpdir INT TERM HUP EXIT
}
echo
echo "------------- Unpacked extension ---------------"
make_trapped_tmpdir
unzip -q -d "$tmpDir" "$cpptoolsZipStorePath"
cpptoolsStorePath="$(nix add-to-store -n "$extStoreName" "$tmpDir")"
cpptoolsSha256="$(nix hash-path --base32 --type sha512 "$cpptoolsStorePath")"
echo "cpptoolsStorePath='$cpptoolsStorePath'"
echo "cpptoolsSha256='$cpptoolsSha256'"
rm_tmpdir
storePathWithSha=$(nix-prefetch-url --print-path "file://${cpptoolsStorePath}/extension/package.json" 2> /dev/null)
extPackageJSONStorePath="$(echo "$storePathWithSha" | tail -n1)"
extPackageJSONSha256="$(echo "$storePathWithSha" | head -n1)"
echo "extPackageJSONStorePath='$extPackageJSONStorePath'"
echo "extPackageJSONSha256='$extPackageJSONSha256'"
print_runtime_dep() {
local outName="$1"
local extPackageJSONStorePath="$2"
local depDesc="$3"
local urlRaw=$(cat "$extPackageJSONStorePath" | jq -r --arg desc "$depDesc" '.runtimeDependencies[] | select(.description == $desc) | .url')
local url=$(echo $urlRaw | xargs curl -Ls -o /dev/null -w %{url_effective})
local urlRawVarStr="${outName}_urlRaw='$urlRaw'"
local urlVarStr="${outName}_url='$url'"
echo "$urlRawVarStr"
echo "$urlVarStr"
local storePathWithSha="$(nix-prefetch-url --unpack --print-path "$url" 2> /dev/null)"
local storePath="$(echo "$storePathWithSha" | tail -n1)"
local sha256="$(echo "$storePathWithSha" | head -n1)"
local sha256VarStr="${outName}_sha256='$sha256'"
local storePathVarStr="${outName}_storePath='$storePath'"
echo "$sha256VarStr"
echo "$storePathVarStr"
eval "$urlRawVarStr"
eval "$urlVarStr"
eval "$sha256VarStr"
eval "$storePathVarStr"
}
echo
echo "------------- Runtime dependencies ---------------"
print_runtime_dep "langComponentBinaries" "$extPackageJSONStorePath" "C/C++ language components (Linux / x86_64)"
print_runtime_dep "monoRuntimeBinaries" "$extPackageJSONStorePath" "Mono Runtime (Linux / x86_64)"
print_runtime_dep "clanFormatBinaries" "$extPackageJSONStorePath" "ClangFormat (Linux / x86_64)"
echo
echo "------------- Runtime deps missing elf deps ---------------"
source "$scriptDir/missing_elf_deps.sh"
echo
echo "------------- Runtime dep mono ---------------"
make_trapped_tmpdir
find "$monoRuntimeBinaries_storePath" -mindepth 1 -maxdepth 1 | xargs -d '\n' cp -rp -t "$tmpDir"
chmod -R a+rwx "$tmpDir"
ls -la "$tmpDir/debugAdapters"
patchelf_mono "$tmpDir/debugAdapters/mono.linux-x86_64"
chmod a+x "$tmpDir/debugAdapters/mono.linux-x86_64"
ldd "$tmpDir/debugAdapters/mono.linux-x86_64"
"$tmpDir/debugAdapters/mono.linux-x86_64" --version
monoRuntimeBinariesPatched_storePath="$(nix add-to-store -n "monoRuntimeBinariesPatched" "$tmpDir")"
echo "monoRuntimeBinariesPatched_storePath='$monoRuntimeBinariesPatched_storePath'"
rm_tmpdir
echo
echo "------------- Runtime dep clang ---------------"
make_trapped_tmpdir
find "$clanFormatBinaries_storePath" -mindepth 1 -maxdepth 1 | xargs -d '\n' cp -rp -t "$tmpDir"
chmod -R a+rwx "$tmpDir"
ls -la "$tmpDir/bin"
patchelf_clangformat "$tmpDir/bin/clang-format"
chmod a+x "$tmpDir/bin/clang-format"
ldd "$tmpDir/bin/clang-format"
"$tmpDir/bin/clang-format" --version
clanFormatBinariesPatched_storePath="$(nix add-to-store -n "clanFormatBinariesPatched" "$tmpDir")"
echo "clanFormatBinariesPatched_storePath='$clanFormatBinariesPatched_storePath'"
rm_tmpdir
echo
echo "------------- Nix mono ---------------"
print_nix_version_clangtools
echo
echo "------------- Nix mono ---------------"
print_nix_version_mono