Development/Tutorials/Debugging/Debugging symbols - Revision history

Icwiener: /* And make? */ markup

2011-06-27T15:51:40Z

‎And make?: markup

Icwiener: Fix syntax highlighting.

2011-06-27T15:51:14Z

Fix syntax highlighting.

SommerLuk: Correct level of titles

2010-08-30T08:47:50Z

Correct level of titles

Jriddell: /* Backtraces */ -j4 excessive for this

2009-07-28T23:12:19Z

‎Backtraces: -j4 excessive for this

Jriddell: /* Example app */ no need for 4 processes on this example

2009-07-28T23:03:11Z

‎Example app: no need for 4 processes on this example

Jriddell: /* Example app */ fix ls command

2009-07-28T23:01:16Z

‎Example app: fix ls command

Tstaerk at 12:09, 12 July 2009

2009-07-12T12:09:34Z

Tstaerk: /* Overview */

2009-07-12T11:54:36Z

‎Overview

Tstaerk: /* Where are they? */

2009-07-11T19:49:11Z

‎Where are they?

Tstaerk at 18:37, 11 July 2009

2009-07-11T18:37:06Z

@@ Line 152: / Line 152: @@
 -DNDEBUG -DQT_NO_DEBUG
 </pre>
-are unique for the release-version. There are further differences like the O2 optimization.
+are unique for the release-version. There are further differences like the <tt>O2</tt> optimization.

@@ Line 1: / Line 1: @@
 == Overview ==
 Debugging symbols allow you to debug your application better. They are added to your binary by the compiler. For KDE, you have to decide during the cmake step if you want debugging symbols or not. To compile your application with debugging symbols, use
- cmake . -DCMAKE_BUILD_TYPE=debugfull
+<pre>
 to compile it without debugging symbols, use
- cmake . -DCMAKE_BUILD_TYPE=release
+<pre>
 Depending on your decision, output generated with the command kDebug will also be (debugfull) or not be (release) added to your application.
@@ Line 10: / Line 14: @@
 '''main.cpp'''
+<syntaxhighlight lang="cpp-qt">
-<pre>
 #include <KApplication>
 #include <KAboutData>
@@ Line 40: / Line 43: @@
      return 0;
+}
-</pre>
+</syntaxhighlight>
 '''CMakeLists.txt'''
 <pre>
@@ Line 53: / Line 57: @@
 </pre>
 Now let's compile this without debugging symbols:
- cmake . -DCMAKE_BUILD_TYPE=release && make
+<pre>
 We see that the resulting file is small:
- # ls -lh tutorial1
+<pre>
- -rwxr-xr-x 1 user user 15K Jul 11 18:07 tutorial1
+# ls -lh tutorial1
 With debugging symbols, the file is bigger:
- cmake . -DCMAKE_BUILD_TYPE=debugfull && make
+<pre>
- # ls -lh tutorial1
+cmake . -DCMAKE_BUILD_TYPE=debugfull && make
- -rwxr-xr-x 1 root root 250K Jul 11 18:09 tutorial1
+# ls -lh tutorial1
 == Backtraces ==
 Now let's start the application and look at the backtrace:
- cmake . -DCMAKE_BUILD_TYPE=release && make
+<pre>
 Gives you the backtrace
- Application: Tutorial 1 (tutorial1), signal SIGSEGV
+<pre>
- �[?1034h[Thread debugging using libthread_db enabled]
+Application: Tutorial 1 (tutorial1), signal SIGSEGV
-x00007f58abba4cb0 in nanosleep () from /lib64/libc.so.6
+�[?1034h[Thread debugging using libthread_db enabled]
- [Current thread is 1 (Thread 0x7f58b0cfd750 (LWP 21264))]
+x00007f58abba4cb0 in nanosleep () from /lib64/libc.so.6
 [Current thread is 1 (Thread 0x7f58b0cfd750 (LWP 21264))]
- Thread 1 (Thread 0x7f58b0cfd750 (LWP 21264)):
- [KCrash Handler]
+Thread 1 (Thread 0x7f58b0cfd750 (LWP 21264)):
- '''#5  0x00000000004016aa in main ()'''
+[KCrash Handler]
 The debugging build
- cmake . -DCMAKE_BUILD_TYPE=debugfull && make
+<pre>
 Gives you the backtrace
- Application: Tutorial 1 (tutorial1), signal SIGSEGV
+<pre>
- �[?1034h[Thread debugging using libthread_db enabled]
+Application: Tutorial 1 (tutorial1), signal SIGSEGV
-x00007fd0b8161cb0 in nanosleep () from /lib64/libc.so.6
+�[?1034h[Thread debugging using libthread_db enabled]
- [Current thread is 1 (Thread 0x7fd0bd2ba750 (LWP 21327))]
+x00007fd0b8161cb0 in nanosleep () from /lib64/libc.so.6
 [Current thread is 1 (Thread 0x7fd0bd2ba750 (LWP 21327))]
- Thread 1 (Thread 0x7fd0bd2ba750 (LWP 21327)):
- [KCrash Handler]
+Thread 1 (Thread 0x7fd0bd2ba750 (LWP 21327)):
- '''#5  0x0000000000401625 in main (argc=1, argv=0x7fffc52f5138) at /root/kdehello/main.cpp:25'''
+[KCrash Handler]
 So you see: with debugging symbols, you see the line number where the crash occurred. Without, you do not see this.
 == Where are they? ==
 Where are the debugging symbols stored? Use objdump -g to find out:
- # objdump  -g tutorial1-release | wc -l
+<pre>
 # objdump  -g tutorial1-release | wc -l
- # objdump  -g tutorial1-debugfull | wc -l
 # objdump  -g tutorial1-debugfull | wc -l
 It is important to know that the code lines (in assembler) to be executed actually do not differ a lot. We see this when disassembling the code:
- # objdump -d tutorial1-debugfull | wc -l
+<pre>
 # objdump -d tutorial1-debugfull | wc -l
- # objdump -d tutorial1-release | wc -l
 # objdump -d tutorial1-release | wc -l
 This gives us hope that there will be no major speed difference between a debug- and a release-version of a binary.
 == Speed implications ==
 We remove the lines that cause the crash and the messagebox. Then we execute the program 100 times:
- cmake . -DCMAKE_BUILD_TYPE=debugfull && make -j4
+<pre>
- time for i in $(seq 1 1 100); do ./tutorial1; done
+cmake . -DCMAKE_BUILD_TYPE=debugfull && make -j4
- real    0m6.201s
+real    0m6.201s
- user    0m4.368s
+user    0m4.368s
- sys     0m1.320s
+sys     0m1.320s
 Lasts 6 seconds. Now with the release version:
- cmake . -DCMAKE_BUILD_TYPE=release && make -j4
+<pre>
- time for i in $(seq 1 1 100); do ./tutorial1; done
+cmake . -DCMAKE_BUILD_TYPE=release && make -j4
- real    0m6.259s
+real    0m6.259s
- user    0m4.368s
+user    0m4.368s
- sys     0m1.328s
+sys     0m1.328s
 Also lasts 6 seconds. So the main difference is in the binaries size.
 == And make? ==
 How does cmake propagate to make if a debug version is wanted? Do a
- cmake . -DCMAKE_BUILD_TYPE=debugfull && make VERBOSE=1
+<pre>
 You will find a difference during the link step. The parameters
- -DNDEBUG -DQT_NO_DEBUG
+<pre>
 are unique for the release-version. There are further differences like the O2 optimization.

@@ Line 1: / Line 1: @@
-= Overview =
+== Overview ==
 Debugging symbols allow you to debug your application better. They are added to your binary by the compiler. For KDE, you have to decide during the cmake step if you want debugging symbols or not. To compile your application with debugging symbols, use
   cmake . -DCMAKE_BUILD_TYPE=debugfull
@@ Line 6: / Line 6: @@
 Depending on your decision, output generated with the command kDebug will also be (debugfull) or not be (release) added to your application.
-= Example app =
+== Example app ==
 As an example, let's write an application that crashes:
@@ Line 62: / Line 62: @@
   -rwxr-xr-x 1 root root 250K Jul 11 18:09 tutorial1
-= Backtraces =
+== Backtraces ==
 Now let's start the application and look at the backtrace:
   cmake . -DCMAKE_BUILD_TYPE=release && make
@@ Line 87: / Line 87: @@
 So you see: with debugging symbols, you see the line number where the crash occurred. Without, you do not see this.
-= Where are they? =
+== Where are they? ==
 Where are the debugging symbols stored? Use objdump -g to find out:
   # objdump  -g tutorial1-release | wc -l
@@ Line 100: / Line 100: @@
 This gives us hope that there will be no major speed difference between a debug- and a release-version of a binary.
-= Speed implications =
+== Speed implications ==
 We remove the lines that cause the crash and the messagebox. Then we execute the program 100 times:
   cmake . -DCMAKE_BUILD_TYPE=debugfull && make -j4
@@ Line 117: / Line 117: @@
 Also lasts 6 seconds. So the main difference is in the binaries size.
-= And make? =
+== And make? ==
 How does cmake propagate to make if a debug version is wanted? Do a
   cmake . -DCMAKE_BUILD_TYPE=debugfull && make VERBOSE=1

@@ Line 64: / Line 64: @@
 = Backtraces =
 Now let's start the application and look at the backtrace:
-  cmake . -DCMAKE_BUILD_TYPE=release && make -j4
+  cmake . -DCMAKE_BUILD_TYPE=release && make
 Gives you the backtrace
   Application: Tutorial 1 (tutorial1), signal SIGSEGV
@@ Line 75: / Line 75: @@
   '''#5  0x00000000004016aa in main ()'''
 The debugging build
-  cmake . -DCMAKE_BUILD_TYPE=debugfull && make -j4
+  cmake . -DCMAKE_BUILD_TYPE=debugfull && make
 Gives you the backtrace
   Application: Tutorial 1 (tutorial1), signal SIGSEGV

@@ Line 53: / Line 53: @@
 </pre>
 Now let's compile this without debugging symbols:
-  cmake . -DCMAKE_BUILD_TYPE=release && make -j4
+  cmake . -DCMAKE_BUILD_TYPE=release && make
 We see that the resulting file is small:
   # ls -lh tutorial1

← Older revision		Revision as of 19:49, 11 July 2009
Line 99:		Line 99:
	697		697
	This gives us hope that there will be no major speed difference between a debug- and a release-version of a binary.		This gives us hope that there will be no major speed difference between a debug- and a release-version of a binary.
		+
		+	= And make? =
		+	How does cmake propagate to make if a debug version is wanted? Do a
		+	cmake . -DCMAKE_BUILD_TYPE=debugfull && make VERBOSE=1
		+	You will find a difference during the link step. The parameters
		+	-DNDEBUG -DQT_NO_DEBUG
		+	are unique for the release-version. There are further differences like the O2 optimization.

	= Speed implications =		= Speed implications =