Android Valgrind Build Fails

May 08, 2024 Post a Comment

Hello I'm trying to build valgrind for android-arm. On Linux Mint 13 it fails with: $ make echo '# This is a generated file, composed of the following suppression rules:' > defa

Solution 1:

For building and installing Valgrind for Android use the bash script below, which I prefer to call build_valgrind.sh

To run with RUN_HELLO_JNI_THROUGH_VALGRIND=true you need two additional scripts (bootstrap_valgrind.sh, start_valgrind.sh) in the directory you run the script below from.

Running the script with the RUN_HELLO_JNI_THROUGH_VALGRIND=true flag will build the hello-jni application from the samples directory inside the Android NDK HOME, deploy it to the phone and run it through Valgrind, using either callgrind or memcheck tool, which you can specify in the start_valgrind.sh script.

The other two scripts are described here: https://stackoverflow.com/a/19235439/313113

Here's my directory structure:

|-- build_valgrind.sh (the script below)
|-- bootstrap_valgrind.sh (second script from https://stackoverflow.com/a/19235439/313113)
|-- start_valgrind.sh (first script from https://stackoverflow.com/a/19235439/313113)
|-- valgrind-3.10.0 (will be extracted by build_valgrind.sh)
`-- valgrind-3.10.0.tar.bz2 (will be downloaded by build_valgrind.sh)

I've tested that its working (memcheck and callgrind tools) on a Samsung Galaxy Nexus device with CyanogenMod 10.2.1 and Android 4.3.1 and CyanogenMod 11 20140804 snapshot, Android 4.4.4

You can see the file size of the generated output with: adb shell ls -lR "/sdcard/*grind*"

The build_valgrind.sh script:

#!/usr/bin/env bash#set -x functionextract()
{
     if [ -f "$1" ] ; thencase"$1"in
             *.tar.bz2)   tar xvjf "$1"     ;;
             *.tar.gz)    tar xvzf "$1"     ;;
             *.bz2)       bunzip2 "$1"      ;;
             *.rar)       unrar x "$1"      ;;
             *.gz)        gunzip "$1"       ;;
             *.tar)       tar xvf "$1"      ;;
             *.tbz2)      tar xvjf "$1"     ;;
             *.tgz)       tar xvzf "$1"     ;;
             *.zip)       unzip "$1"        ;;
             *.Z)         uncompress "$1"   ;;
             *.7z)        7z x "$1"         ;;
             *)           echo"$1 cannot be extracted via >extract<" ;;
         esacelseecho"'$1' is not a valid file"fi
}

RUN_HELLO_JNI_THROUGH_VALGRIND=true
VALGRIND_VERSION="3.10.0"
VALGRIND_EXTENSION=".tar.bz2"
VALGRIND_DIRECTORY="valgrind-${VALGRIND_VERSION}"
VALGRIND_TARBALL="valgrind-${VALGRIND_VERSION}${VALGRIND_EXTENSION}"# Only download Valgrind tarball again if not already downloadedif [[ ! -f "${VALGRIND_TARBALL}" ]]; then
  wget -v -nc "http://valgrind.org/downloads/${VALGRIND_TARBALL}"fi# Only extract Valgrind tarball again if not already extractedif [[ ! -d "$VALGRIND_DIRECTORY" ]]; then
  extract "$VALGRIND_TARBALL"fi# Ensure ANDROID_NDK_HOME is setif [[ ! -z "$ANDROID_NDK_HOME" ]]; thenexport ANDROID_NDK_HOME="$HOME/Software/Android/android-ndk-r10c"fi# Ensure ANDOID_SDK_HOME is setif [[ ! -z "$ANDROID_SDK_HOME" ]]; thenexport ANDROID_SDK_HOME="$HOME/Software/Android/android-sdk/"fiif [[ ! -d "$VALGRIND_DIRECTORY" ]];
thenecho"Problem with extracting Valgrind from $VALGRIND_TARBALL into $VALGRIND_DIRECTORY!!!"exit -1
fi# Move to extracted directorycd"$VALGRIND_DIRECTORY"# ARM Toolchain
ARCH_ABI="arm-linux-androideabi-4.9"export AR="$ANDROID_NDK_HOME/toolchains/${ARCH_ABI}/prebuilt/linux-x86_64/bin/arm-linux-androideabi-ar"export LD="$ANDROID_NDK_HOME/toolchains/${ARCH_ABI}/prebuilt/linux-x86_64/bin/arm-linux-androideabi-ld"export CC="$ANDROID_NDK_HOME/toolchains/${ARCH_ABI}/prebuilt/linux-x86_64/bin/arm-linux-androideabi-gcc"export CXX="$ANDROID_NDK_HOME/toolchains/${ARCH_ABI}/prebuilt/linux-x86_64/bin/arm-linux-androideabi-g++"

[[ ! -d "$ANDROID_NDK_HOME" || ! -f "$AR" || ! -f "$LD" || ! -f "$CC" || ! -f "$CXX" ]] && echo"Make sure AR, LD, CC, CXX variables are defined correctly. Ensure ANDROID_NDK_HOME is defined also" && exit -1

# Configure buildexport HWKIND="nexus_s"
ANDROID_PLATFORM=android-18
export CPPFLAGS="--sysroot=$ANDROID_NDK_HOME/platforms/${ANDROID_PLATFORM}/arch-arm -DANDROID_HARDWARE_$HWKIND"export CFLAGS="--sysroot=$ANDROID_NDK_HOME/platforms/${ANDROID_PLATFORM}/arch-arm"# BUG: For some reason file command is unable to detect if the file does not exist with ! -f , it says it doesn't exist even when it does!!!
BUILD=falseif [[ "${VALGRIND_DIRECTORY}/Inst/data/local/Inst/bin/valgrind" = *"No such file or directory"* ]]; then
  BUILD=truefiif [[ "$BUILD" = true ]];
then
  ./configure --prefix="/data/local/Inst" \
  --host="armv7-unknown-linux" \
  --target="armv7-unknown-linux" \
  --with-tmpdir="/sdcard "

  [[ $? -ne 0 ]] && echo"Can't configure!" && exit -1

  # Determine the number of jobs (commands) to be run simultaneously by GNU Make
  NO_CPU_CORES=$(grep -c ^processor /proc/cpuinfo)

  if [ $NO_CPU_CORES -le 8 ]; then
    JOBS=$(($NO_CPU_CORES+1))
  else
    JOBS=${NO_CPU_CORES}fi# Compile Valgrind 
  make -j "${JOBS}"

  [[ $? -ne 0 ]] && echo"Can't compile!" && exit -1

  # Install Valgrind locally
  make -j "${JOBS}" install DESTDIR="$(pwd)/Inst"
  [[ $? -ne 0 ]] && echo"Can't install!" && exit -1
fi# Push local Valgrind installtion to the phoneif [[ $(adb shell ls -ld /data/local/Inst/bin/valgrind) = *"No such file or directory"* ]];
then
  adb root
  adb remount
  adb shell "[ ! -d /data/local/Inst ] && mkdir /data/local/Inst"
  adb push Inst /
  adb shell "ls -l /data/local/Inst"# Ensure Valgrind on the phone is running
  adb shell "/data/local/Inst/bin/valgrind --version"# Add Valgrind executable to PATH (this might fail)
  adb shell "export PATH=$PATH:/data/local/Inst/bin/"fiif [ $RUN_HELLO_JNI_THROUGH_VALGRIND = true ]; then
  PACKAGE="com.example.hellojni"# The location of the Hello JNI sample application
  HELLO_JNI_PATH="$ANDROID_NDK_HOME/samples/hello-jni"pushd"$HELLO_JNI_PATH"# Update build target to the desired Android SDK version
  ANDROID_PROJECT_TARGET="android-18"
  android update project --target "$ANDROID_PROJECT_TARGET" --path . --name hello-jni --subprojects

  # Enable Android NDK build with Antecho'<?xml version="1.0" encoding="utf-8"?>

    <project name="HelloJni" basedir="." default="debug">

    <target name="-pre-build">
      <exec executable="${ndk.dir}/ndk-build" failonerror="true"/>
    </target>

    <target name="clean" depends="android_rules.clean">
      <exec executable="${ndk.dir}/ndk-build" failonerror="true">
      <arg value="clean"/>
      </exec>
    </target> 

    </project>
  ' > "custom_rules.xml"# Set NDK HOME for Ant (only if not already set)if ! grep -P -q "ndk.dir=.+""local.properties" ; thenecho -e "\nndk.dir=$ANDROID_NDK_HOME" >> "local.properties"fi# Fix for Java 8 warning (warning: [options] source value 1.5 is obsolete and will be removed in a future release)echo"java.compilerargs=-Xlint:-options" >> "ant.properties"# Workaround INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES error
  adb uninstall "$PACKAGE"# Build Hello JNI project in debug mode and install it on the device
  ant clean && ant debug && ant installd

  popdcd ..  

  # Start HelloJNI app 
  adb shell am start -a android.intent.action.MAIN -n $PACKAGE/.HelloJni

  # Make the script executablechmod a+x bootstrap_valgrind.sh

  # Run application through Valgrind on the phone
  /usr/bin/env bash bootstrap_valgrind.sh

  adb shell ls -lR "/sdcard/*grind*"
  adb shell ls -lR "/storage/sdcard0/*grind*"
  adb shell ls -lR "/storage/sdcard1/*grind*"fiexit 0

Solution 2:

This gets valgrind to compile for me on linux. (using android-ndk-r8e and valgrind-3.8.1)

There was no need to run autogen.sh since I downloaded the tar ball from the website.

Also make sure the TOOLCHAIN= line points to a valid toolchain.

Baca Juga

export NDK_HOME=$HOME/Downloads/android-ndk-r8e

export HWKIND=generic

export TOOLCHAIN=$NDK_HOME/toolchains/arm-linux-androideabi-4.7/prebuilt/linux-x86_64/bin/arm-linux-androideabi

export AR=$TOOLCHAIN-ar
export LD=$TOOLCHAIN-ld
export CC=$TOOLCHAIN-gcc

CPPFLAGS="--sysroot=$NDK_HOME/platforms/android-14/arch-arm -DANDROID_HARDWARE_$HWKIND" \
    CFLAGS="--sysroot=$NDK_HOME/platforms/android-14/arch-arm" \
    ./configure --prefix=/data/local/Inst \
    --host=armv7-unknown-linux --target=armv7-unknown-linux \
    --with-tmpdir=/sdcard

make

It eventually came up with a compile error saying

$NDK_HOME/platforms/android-14/arch-arm/usr/include/elf.h:58:3: error: unknown type name 'uint32_t'

It seem like someone forgot to add #include <stdint.h> somewhere. To fix this I edited $NDK_HOME/platforms/android-14/arch-arm/usr/include/elf.h and added #include <stdint.h> to the include section of this header. NOTE: This is probably not the best fix but it is the one that I came up with that fixed the compilation errors.

On mac I was able to get it to compile up until the unknown type uint32_t part by changing how the configure script checks the kernel version.

Inside the configure script search of a line kernel=`uname -r` and change it to kernel=3.9.2. (There are two kernel=`uname -r` lines replace the first one or both if you feel like it)

This stops the configure script from looking at the host kernel when deciding how it should build valgrind. (uname -r grabs the host kernel)

I believe adding the #include <stdint.h> to elf.h should work on mac to but I have not tested it.

Solution 3:

in android tutorial one option is missed RANLIB, after I set it - I finally compiled valgrind-3.11.0 on osx for android

#/bin/shecho"NKDROOT: "$NDKROOTexport ANRDOID_TOOLCHAIN="arm-linux-androideabi-4.9"# Set up toolchain paths.## For ARMexport AR=$NDKROOT/toolchains/$ANRDOID_TOOLCHAIN/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-ar
export LD=$NDKROOT/toolchains/$ANRDOID_TOOLCHAIN/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-ld
export CC=$NDKROOT/toolchains/$ANRDOID_TOOLCHAIN/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-gcc
export CXX=$NDKROOT/toolchains/$ANRDOID_TOOLCHAIN/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-g++
export RANLIB=$NDKROOT/toolchains/$ANRDOID_TOOLCHAIN/prebuilt/darwin-x86_64/bin/arm-linux-androideabi-ranlib

echo"AR: "$ARecho"LD: "$LDecho"CC: "$CCecho"CXX: "$CXX

[[ ! -d "$NDKROOT" || ! -f "$AR" || ! -f "$LD" || ! -f "$CC" || ! -f "$CXX" ]] && echo"Make sure AR, LD, CC, CXX variables are defined correctly. Ensure NDKROOT is defined also" && exit -1

./autogen.sh

#if [ $? -ne 0 ]#then#    exit 1#else#    echo "autogen success!"#fi# for ARM
ANDROID_PLATFORM=android-3
ANDROID_SYSROOT="$NDKROOT/platforms/${ANDROID_PLATFORM}/arch-arm"echo"SYSROOT: "$ANDROID_SYSROOTexport HWKIND=generic 
export CPPFLAGS="--sysroot=$ANDROID_SYSROOT -DANDROID_HARDWARE_$HWKIND"export CFLAGS="--sysroot=$ANDROID_SYSROOT -DANDROID_HARDWARE_$HWKIND"export LDFLAGS="--sysroot=$ANDROID_SYSROOT -DANDROID_HARDWARE_$HWKIND"export ARFLAGS="--sysroot=$ANDROID_SYSROOT -DANDROID_HARDWARE_$HWKIND"

./configure \
    --prefix=/data/local/Inst \
    --host=armv7-unknown-linux --target=armv7-unknown-linux \
    --with-tmpdir=/sdcard

if [ $? -ne 0 ]
thenexit 1
elseecho"configure success!"fi# note: on android emulator, android-14 platform was also tested and works.# It is not clear what this platform nr really is.

make -j7
if [ $? -ne 0 ]
thenexit 1
elseecho"build success!"fi

make -j7 install DESTDIR=`pwd`/Inst

Solution 4:

The problem I had was that the configure script was ignoring the environment variables. To configure the make file I instead did this:

sudo ./configure --prefix=/data/local/Inst --host=armv7-unknown-linux --target=armv7-unknown-linux --with-tmpdir=/sdcard0 CPPFLAGS="--sysroot=$NDKROOT/platforms/android-3/arch-arm -DANDROID_HARDWARE_$HWKIND" CFLAGS="--sysroot=$NDKROOT/platforms/android-3/arch-arm" CC=$CC LD=$LD AR=$AR

This ensures the variables are set properly and works with Linux Mint 13. It does not work on OSX Mountain Lion however. I'd advise anyone using OSX without access to a linux installation to try using linux on a virtual machine.

Android Coder

Android Valgrind Build Fails

Solution 1:

Solution 2:

Solution 3:

Solution 4:

Post a Comment for "Android Valgrind Build Fails"