How C/C++ Debugging Works on Android

http://mhandroid.wordpress.com/2011/01/25/multithread-cc-debugging-on-emulators-and-rooted-devices-from-android-1-5/

Multithread C/C++ Debugging on Emulators and Rooted Devices from Android 1.5 原文带图

In Android 2.2 Google announced ndk-gdb script which ease the debugging on the device. Later it turns out that it is not capable of debugging any other thread than
the main thread.

In Android 2.3 Google ships fixed setup so you are now finally able to debug multithread application.

In fact multithread debugging is possible at least from Android 1.5. But you have to set up the environment yourself. Due to permissions limitation it is only possible
on rooted devices. But it is possible on emulator as emulator is always rooted!

Here is a small shell script which does everything for you. It will start gdbserver on the device, gdb on PC and connect them together. It will also set up paths
correctly so gdb can find its unstripped libraries on PC while having stripped libraries on the device.

Run this script from your project root directory. You have to modify APP_PACKAGE and ANDROID_TARGET variables to match your project settings. You also need to have
you project compiled in debug mode. This can be done by running ndk-build NDK_DEBUG=1 or by setting android:debuggable=”true” in AndroidManifest.xml and compiling normally.

001

#!/bin/bash

002

# Martin Hejna (c) 2011

003

# martin.hejna@gmail.com

004

# CC-by

005

006

007

## Comment out for quiet run

008

set -x

009

010

# Set those variables to match your application

011

[ "$APP_PACKAGE" ] || APP_PACKAGE="com.example"

012

[ "$ANDROID_TARGET" ] || ANDROID_TARGET="android-9"

013

014

# Set installation paths of SDK and NDK

015

[ "$ANDROID_SDK" ] || ANDROID_SDK="/home/martin/Android/android-sdk-linux_86"

016

[ "$ANDROID_NDK" ] || ANDROID_NDK="/home/martin/Android/android-ndk-r5"

017

018

# adb and gdb executable paths

019

ADB="$ANDROID_SDK"/platform-tools/adb

020

GDB=$ANDROID_NDK/toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin/arm-linux-androideabi-gdb

021

022

# Check we are in application root path (the one with AndroidManifest.xml in it)

023

APP_ROOT=`dirname $0`

024

if [ ! -f $APP_ROOT/AndroidManifest.xml ]

025

then

026

echo This script must be run from package root directory

027

echo This is the directory with AndroidManifest.xml in it

028

exit 1

029

fi

030

031

# Path to unstripped versions of native .so libraries

032

UNSTRIPPED_SO_LIB="$APP_ROOT/obj/local/armeabi"

033

APP_PROCESS=$UNSTRIPPED_SO_LIB/app_process

034

APP_LIBC_SO=$UNSTRIPPED_SO_LIB/libc.so

035

if [ ! -d $UNSTRIPPED_SO_LIB ]; then

036

echo Error: Directory $UNSTRIPPED_SO_LIB does not exist

037

exit 1

038

fi

039

040

# Use cgdb if available

041

if which cgdb > /dev/null

042

then GDB_CMD="cgdb -d $GDB --"

043

else GDB_CMD=$GDB

044

fi

045

046

# We use same port number on pc and on device

047

DEBUG_PORT=5039

048

049

# File with gdb setup instructions (executed when gdb starts)

050

[ "$GDB_SETUP" ] || GDB_SETUP="/tmp/gdb.setup"

051

052

053

# Generate setup file for gdb with appropriate paths to symbols

054

function gdb_setup()

055

{

056

cat <<EOF >$GDB_SETUP

057

set solib-search-path $UNSTRIPPED_SO_LIB:$ANDROID_NDK/platforms/$ANDROID_TARGET/arch-arm/usr/lib

058

directory $ANDROID_NDK/platforms/$ANDROID_TARGET/arch-arm/usr/include $APP_ROOT/jni $ANDROID_NDK/sources/cxx-stl/system

059

## set solib-absolute-prefix $ANDROID_NDK/platforms/$ANDROID_TARGET/arch-arm/usr/lib

060

061

file $APP_PROCESS

062

target remote :$DEBUG_PORT

063

064

# Probably not needed. Uncomment if you have problems with watchdogs

065

## set variable gDvm.nativeDebuggerActive=true

066

EOF

067

}

068

069

# Get pid of the process (first one if there are more of them)

070

function get_pid_on_device()

071

{

072

$ADB shell ps | grep "$@" | awk '{print $2; exit}'

073

}

074

075

076

#############################################################################

077

## Main entry

078

############################################################################

079

080

081

# Restart adb server. Uncomment if you have problems with adb being stuck

082

## $ADB kill-server

083

084

# Get the app_process and libc.so from the device

085

# Always download and overwrite those files to be sure we have correct ones

086

$ADB pull /system/bin/app_process $APP_PROCESS

087

$ADB pull /system/lib/libc.so $APP_LIBC_SO

088

089

# Set up port forwarding for gdb and gdbserver

090

if $ADB forward tcp:$DEBUG_PORT tcp:$DEBUG_PORT

091

then :

092

else

093

echo Failed to setup tcp forwarding for port $DEBUG_PORT

094

echo Is the device running?

095

exit 1

096

fi

097

098

# Get pid of the process

099

APP_PID=`get_pid_on_device "$APP_PACKAGE"`

100

if [ -z $APP_PID ]

101

then

102

echo "$APP_PACKAGE is not running"

103

exit 1

104

fi

105

106

# Kill any prior gdbserver

107

GDBSERV_PID=`get_pid_on_device gdbserver`

108

if [ -n "$GDBSERV_PID" ]

109

then

110

$ADB shell kill $GDBSERV_PID

111

sleep 1

112

fi

113

114

# Start gdbserver and attach it to our application

115

$ADB shell gdbserver :$DEBUG_PORT --attach $APP_PID &

116

sleep 2

117

118

# Invoke gdb and feed it with setup commands to set up path to libraries

119

gdb_setup

120

$GDB_CMD -x $GDB_SETUP

121

rm -f $GDB_SETUP

Have fun!

----------------------------------------------------------------------------------------------------------

How C/C++ Debugging Works on Android(http://mhandroid.wordpress.com/2011/01/25/how-cc-debugging-works-on-android/)

Posted on January 25, 2011

How debugging of C/C++ code works on Android? Nothing special actually. Gdb itself has a feature for remote debugging.

Note: For this article I am using Android NDK, r5. The behavior of ndk-build and ndk-gdb commands can be different in other versions.

Basic setup

You simply run gdbserver on the device and let it attach to some process. Gdbserver acts as a remote debugger which is commanded by gdb itself. This step is pretty
easy and is done by some variant of

gdbserver :5039 --attach 123

where 5039 is a TCP port number to which gdb will connect and 123 is a PID of process we want to debug.

The next step is to run gdb client and connect it to the gdbserver on the device. You need to start gdb with command

gdb app_process

where app_process is Android binary which you need to copy from Android device to your PC. This binary is some kind of loader and lies in /system/bin/app_process
file on the device (or in the emulator).

After you start gdb you connect it with the gdbserver by this command (ran from gdb shell)

target remote :5039

Because you are usually running Android device connected through USB and not normal TCP/IP network (or you are running Android emulator) you have to set up TCP port
forwarding in advance. This is done by command

adb forward tcp:5039 tcp:5039

which you have to execute before starting gdb. This command will handle all connection requests to port 5039 on PC to the device on the same port.

And this is all.

Debug symbols

You typically compile your .so library with debug symbols. But it makes good sense to strip those symbols off before uploading your binary to the Android device.
Binary will be smaller (which means faster installation time of the apk package), will occupy less memory and will run faster. So you upload stripped version of your libraries to the Android device and keep unstripped versions on your PC.

To tell gdb the path to the unstripped libraries run this command from gdb shell

set solib-search-path obj/local/armeabi

You can enter more paths and separate them by colon (:) character.

There is a difference between debug symbols and code optimization. Code optimization allows changing the code flow or removing some dead-code and unused variables.
While debug symbols bind machine code together with appropriate lines in the source code. Usually you build a binary with debug symbols and no code optimization for debugging and another binary without debug symbols and with some code optimization for release.
But you can use debug symbols together with code optimization. In this case some variables will be missing and some lines of code will be probably jumped over but in general you can debug this way.

Android ndk-build command always produce binaries (your libnative.so files) with debug symbols and place them in obj/local/armeabi subdirectory of your project. Then
it strips off debug symbols and place stripped version in the final .apk (and thus in the device). ndk-gdb script uses this set solib-search-path command to point gdb to the unstripped binary so you can see your position in the source code. You can find the
set solib-search-path command in obj/local/armeabi/gdb.setup file.

If you have android:debuggable=”true” in your AndroidManifest.xml or if you run ndk-build with NDK_DEBUG=1 argument then ndk-build will produce binaries with no code
optimization. Otherwise code optimization will be used.

Sources

Gdb needs to have access to your source files. Otherwise it cannot show you the source code as it is executed. You can configure directory with your source files
by command

directory jni

You can enter more paths and separate them by space. Take a look into obj/local/armeabi/gdb.setup file for example.

How ndk-gdb and friends works

If you are using Android NDK, r5 and Android 2.3 device you can use ndk-gdb script which does everything for you.

If you have android:debuggable=”true” in your AndroidManifest.xml then ndk-build will add the gdbserver into your .apk package. This gdbserver will be started by
ndk-gdb and also all the other steps will be set up by this script.

Important caveat

Because gdbserver is attached to the already running process (as opposed to situation where process would be started by gdbserver) it can miss some code execution
which take place soon after the application start. There is no easy solution to this.

I usually write some endless while loop and then change the control variable after gdb is fully started. For example

1

int i = 0

2

while (!i) {

3

a++;

4

}

After ndk-gdb starts gdb session I can set breakpoints appropriately and change value of i variable by command

set var i=1

and then continue in application execution by gdb command c.

Multithread debug problem

It is well-known problem that ndk-gdb shipped with Android NDK, r4b used on Android 2.2 device was only able to hit the breakpoint on the main thread. If you set
breakpoint on any other thread gdb session will crash.

Every time new thread is created libc will call _thread_created_hook() function (which has empty body). The purpose of this function is that gdb will set breakpoint
on this function and thus will know that new thread was created. Gdb will then keep database of existing threads. Because of this gdb needs to have access to the libc.so file to figure out address of the _thread_created_hook() function.

Android NDK, r5 contains ndk-gdb which copies the file libc.so from the device (or emulator) and stores it in obj/local/armeabi subdirectory of your project. Also
gdbserver included in this ndk is compiled with libthread_db support. Both those two things are missing in Android NDK, r4b.

Links

Description of multithreading debug bug.
http://code.google.com/p/android/issues/detail?id=9713
Android NDK, r5
http://dl.google.com/android/ndk/android-ndk-r5-linux-x86.tar.bz2
Android ndk main page
http://developer.android.com/sdk/ndk/index.html
---------------------------------------------------------------------------------------------------------------
http://mhandroid.wordpress.com/2011/01/23/using-eclipse-for-android-cc-debugging/ 原文带图

Using Eclipse for Android C/C++ Debugging

Posted on January 23, 2011

Yes. You can use Eclipse for debugging of C/C++ code. I personally prefer cgdb but if you want to debug in Eclipse here is how.

See my previous spot how to set up cgdb debugger if you think it will suit you.

See my blog spot how to set up Eclipse for compiling and editing C/C++ code.

0) Prerequisities

You need Eclipse with CDT installed.

See my previous spot how to do it.

You also need Android ndk. Download it from http://developer.android.com/sdk/ndk/index.html and unpack it somewhere.

1) In Eclipse open your Android project which contains C/C++ code that you want to debug.

For this tutorial I’ve created simple MyAndroidProject.

2) Set android:debuggable=”true”. Set android:targetSdkVersion=”9″.

android:debuggable is a property of <application> tag in your AndroidManifest.xml. You can set it either directly in xml or in Application tab as in the screenshot.

android:targetSdkVersion=”9″ is a property of <uses-sdk> tag in your AndroidManifest.xml. You can set it either directly in xml or in Manifest tab as in the screenshot.

3) Run your application in debug mode and try to run ndk-gdb from console

To run application in debug mode press debug button (green bug/spider button in toolbox). In console go to your project directory and run ndk-gdb. It should succeed.
If it fails you have to resolve the problem. Running ndk-gdb does not only ensure us that we are doing everything right so far, but also creates app_process, gdb.setup and libc.so files in obj/local/armeabi/ subdirectory of our project. Those files will be
needed in later steps.

4) Create C/C++ debug configuration

Click on combo-box like down arrow next to debug button. Pop-up menu will appear and then select Debug Configurations…

In Debug Configurations window select C/C++ Application and press New button as advised on the right pane.

5) Set name of the debug configuration, and fill information on Main tab.

Select Standard Create Process Launcher by clicking on the blue Select other… link at the bottom of the window.

In C/C++ Application entry fill the path to the app_process binary which is located in obj/local/armeabi/ subdirectory of your project.

6) Click on Debugger tab and fill information about debugger.

Choose gdbserver Debugger as a Debugger.

It’s good idea to set initial breakpoint to some function but Android projects do not contain main function so fill some appropriate function name in Stop on startup
field (I filled Java_com_example_map_MyAndroidProject_doSomething but you can see only Java_com_exam on the screenshot).

Set path to GDB debugger. The debugger is distributed with the Android ndk. Its located at toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin/arm-linux-androideabi-gdb.

Set path to GDB command line. This path should point to obj/local/armeabi/gdb2.setup file inside your project. You don’t have gdb2.setup file there yet but you will
create one in a while.

7) Click on the Connection tab (so you are in Debugger->Connection section of your C/C++ debug configuration) and fill information about connecting gdb with gdbserver.

Choose TCP as a type of connection and choose 5039 as a Port number.

8) Finally click Apply to save all the information about your C/C++ debug configuration.

This will save your new C/C++ debug configuration. Later, when running your application in debug mode you can choose in combo box associated with Debug button what
debug configuration you want to use. Now you have two debug configurations. Android Java one which was created automatically for you when you’ve created Android project. And C/C++ one you’ve just created.

9) Go to the obj/local/armeabi/ subdirectory of your project and copy gdb.setup file to gdb2.setup file. Remove target remote :5039 line from gdb2.setup.

Eclipse don’t like target remote :5039 line in gdb setup file because it wants to enter this command internally (that is why you configured port 5039 in the previous
step). Because the gdb.setup file is recreated by ndk scripts you have to copy it to the gdb2.setup and point Eclipse to the gdb2.setup file (we did this in step 6).

10) Go to the directory with Android ndk and copy ndk-gdb to ndk-gdb-eclipse. Remove execution of gdb command from ndk-gdb-eclipse.

Original content of ndk-gdb (Android NDK, r5):

578

if [ -n "$OPTION_EXEC" ] ; then

579

cat $OPTION_EXEC >> $GDBSETUP

580

fi

581

$GDBCLIENT -x `native_path $GDBSETUP`

Content of ndk-gdb-eclipse:

578

if [ -n "$OPTION_EXEC" ] ; then

579

cat $OPTION_EXEC >> $GDBSETUP

580

fi

581

## $GDBCLIENT -x `native_path $GDBSETUP`

Eclipse will run the gdb binary itself. So we have to remove the execution of gdb from ndk-gdb. To save original content it is good idea to copy the ndk-gdb to ndk-gdb-eclipse.

11) Now you are done. Put breakpoint in Java code after the execution of System.loadLibrary() and start your application in Debug mode.

Start your application in debug mode by clicking on Debug button. It will automatically choose Android debug mode. Later you will have to take care to choose Android
Java debugging configuration by clicking on combo arrow associated with the debug button.

The reason that breakpoint should be after System.loadLibrary() call is that our C/C++ code will be already loaded in that point and we can set breakpoints in it.

12) When execution reach the breakpoint run ndk-gdb-eclipse from your project directory and start debugging in C/C++ debug mode.

Go to the directory with your project and run ndk-gdb-eclipse. This will start server-part of the debugging infrastructure. Now click on the combo arrow associated
with the debug button in Eclipse and choose Debug Configurations… Choose your C/C++ debug configuration and click Debug button.

The C/C++ debug configuration will be added to recently used debug configurations so later you don’t have to walk into the Debug Configurations… window again and
you can choose between Android Java debug configuration and C/C++ debug configuration by just clicking on the combo arrow associated with debug button in Eclipse. However always make sure which debug configuration you are about to execute as this is where
mistakes happen very often (at least for me).

After you’ve started C/C++ debug configuration click Resume button (or press F8). The application should resume its run and stop on C/C++ breakpoint (if you have
one).

13) Now you are debugging the C/C++ code. Have fun!

Try to set some breakpoints in C/C++ code, etc.

Note on running ndk-gdb-eclipse

You have to run ndk-gdb-eclipse every time before starting C/C++ debug session. This script starts the gdbserver binary on device/emulator so gdb (run by Eclipse)
can connect to it.

I made several attempts to force Eclipse to run ndk-gdb-eclipse script itself on start of C/C++ debug session. The most logical point is to write small script which
will run ndk-gdb-eclipse without parameters (or with –force parameter) and then run gdb from Android ndk toolchain with all the parameters. This script can be used as GDB debugger command in the Debugger tab. But even if this script (and ndk-gdb-eclipse inside)
was run successfully, the resulting connection of gdb and gdbserver always broke apart.

Final note and thanks!

This tutorial is heavily inspired by Sequoyah Project native debug tutorial. See http://www.eclipse.org/sequoyah/documentation/native_debug.php
Many thanks to you guys.

---------------------------------------------------------------------------------------------------------------
http://mhandroid.wordpress.com/2011/01/23/using-cgdb-with-ndk-debug-and-cgdb-tutorial/ 原文带图

Using cgdb with ndk-debug (and cgdb tutorial)

Posted on January 23, 2011

Android ndk (http://developer.android.com/sdk/ndk/index.html) comes with ndk-gdb command that starts gdb debugger and connects it to Android application.

cgdb (http://cgdb.sourceforge.net/) is superior console front-end to gdb so it seems logical to use it for debugging of Android applications. Following modification
of ndk-gdb script will cause that cgdb will be invoked instead of gdb.

Original ndk-gdb (Android NDK, r5):

569

# Now launch the appropriate gdb client with the right init commands

570

#

571

GDBCLIENT=${TOOLCHAIN_PREFIX}gdb

572

GDBSETUP=$APP_OUT/gdb.setup

Modified ndk-gdb (originally from Android NDK, r5) which uses cgdb instead of gdb:

569

# Now launch the appropriate gdb client with the right init commands

570

#

571

GDBCLIENT="cgdb -d ${TOOLCHAIN_PREFIX}gdb --"

572

GDBSETUP=$APP_OUT/gdb.setup

Now if you run ndk-gdb you will get cgdb front-end.

Small cgdb tutorial

In cgdb you can have focus either on source window (part with the source text) or gdb window.

To switch from source window to gdb press i.

To switch from gdb window to source press esc.

Commands you can use in source window:

arrows — scroll the text

space — set or delete breakpoint

o — open source file

i — switch focus to gdb window

- — make source window 1 line smaller

= — make source window 1 line bigger

Commands you can use in gdb window:

n — next instruction. Will not dive into subfunctions

s — step. Will dive into subfunctions

c — continue

b — set breakpoint

bt — show call stack (backtrace)

info threads — show information about running threads

info breakpoints — show information about breakpoints

pgup, pgdown — scroll the content of gdb window

esc — switch focus to source windows

Full cgdb documentation is at http://cgdb.sourceforge.net/docs/cgdb-no-split.html
Full gdb documentation is at http://www.gnu.org/software/gdb/documentation/
Have fun!

---------------------------------------------------------------------------------------------------------------
http://mhandroid.wordpress.com/2011/01/23/using-eclipse-for-android-cc-development/ 原文带图

Programming in C/C++ on Android is just awesome! This tutorial shows how to setup Eclipse for using C/C++ together with Java in Android projects.

0) Prerequisities

You need to have Google ADT (Android Development Tools) installed. See http://developer.android.com/sdk/eclipse-adt.html how to do it.

You also need Android ndk. Download it from http://developer.android.com/sdk/ndk/index.html and unpack it somewhere.

1) Install CDT (C/C++ Development Tools) into Eclipse.

Choose Help->Install New Software… from the main menu.

Choose http://download.eclipse.org/releases/galileo as the source site. If you have another Eclipse release than Galileo choose the appropriate url.

Click Next, Accept licences and finish the installation process.

2) In Eclipse create Android project to which you want to add C/C++ code (if you already don’t have one).

For this tutorial I’ve created simple MyAndroidProject.

3) In file manager create jni/ directory in your project directory and place your C/C++ sources file here. Also put here Android.mk file which is a makefile that
tells Android build-system how to build your files.

Take a look into Android ndk docs/ANDROID-MK.html file how to create one.

Simple example of Android.mk file:

01

LOCAL_PATH := $(call my-dir)

02

03

include $(CLEAR_VARS)

04

05

LOCAL_LDLIBS := -llog

06

07

LOCAL_MODULE := native

08

LOCAL_SRC_FILES := native.c

09

10

include $(BUILD_SHARED_LIBRARY)

4) Refresh (F5) directories in Package Explorer to see jni directory here. Open your .c/.cpp file.

Your .c/.cpp file (native.c in my case) contains a lot of syntax errors which are not truly syntax errors. This is because Eclipse threats the project as a pure Java
project. We have to convert the project into mixed Java & C/C++ project.

5) Press Ctrl+n (or choose File->New->Other… from main menu) and select Convert to a C/C++ Project.

This will convert your project into a mixed Java & C/C++ project rather than into pure C/C++ project (the name of the function is misleading).

Click Next. Then choose your project and below choose Makefile project and – Other Toolchain –. Click Finish.

After doing this Eclipse will ask you if you want to switch to C/C++ perspective. Choose Yes because otherwise you wouldn’t be able to set C/C++ build preferences.

6) Click on your project with right button and select Properties or press Alt+Enter

Properties windows will appear. Here you have to configure use of ndk-build instead of make all command and set proper include paths.

7) Choose C/C++ Build and configure ndk-build as a build command

In Builder settings fill ndk-build into Build command entry. You have to uncheck Use default build command. You also need to have ndk-build script in your PATH.

In Behaviour setting uncheck clean (ndk-build cleans project automatically on build and does not support separate clean command) and clear all text from build (ndk-build
does not accept all as a parameter.

Click Apply to save settings.

8) Choose C/C++ General->Paths and Symbols and configure include path

In Includes tab choose GNU C or GNU C++ and click Add… button. Add path to include directory which is located in platforms/android-4/arch/arm/usr/include subdirectory
of place where you’ve unpacked Android ndk. Include path depends on target for which you are compiling (android-4 in my case — i.e. Android 1.6).

Finally click Apply and OK and that is all. Now you can use all Eclipse power for editing your C/C++ sources. If you click Run or Debug Eclipse will compile C/C++
code as well as Java code and run it on device/emulator. However you will not be able to debug C/C++ code.