36 lines
23 KiB
HTML
36 lines
23 KiB
HTML
<!DOCTYPE html>
|
|
<html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>gdb debugging tips · The Julia Language</title><script>(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
|
|
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
|
|
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
|
|
})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
|
|
|
|
ga('create', 'UA-28835595-6', 'auto');
|
|
ga('send', 'pageview');
|
|
</script><link href="https://cdnjs.cloudflare.com/ajax/libs/normalize/4.2.0/normalize.min.css" rel="stylesheet" type="text/css"/><link href="https://fonts.googleapis.com/css?family=Lato|Roboto+Mono" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" type="text/css"/><link href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.12.0/styles/default.min.css" rel="stylesheet" type="text/css"/><script>documenterBaseURL=".."</script><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.2.0/require.min.js" data-main="../assets/documenter.js"></script><script src="../siteinfo.js"></script><script src="../../versions.js"></script><link href="../assets/documenter.css" rel="stylesheet" type="text/css"/><link href="../assets/julia-manual.css" rel="stylesheet" type="text/css"/></head><body><nav class="toc"><a href="../index.html"><img class="logo" src="../assets/logo.png" alt="The Julia Language logo"/></a><h1>The Julia Language</h1><select id="version-selector" onChange="window.location.href=this.value" style="visibility: hidden"></select><form class="search" id="search-form" action="../search.html"><input id="search-query" name="q" type="text" placeholder="Search docs"/></form><ul><li><a class="toctext" href="../index.html">Home</a></li><li><span class="toctext">Manual</span><ul><li><a class="toctext" href="../manual/introduction.html">Introduction</a></li><li><a class="toctext" href="../manual/getting-started.html">Getting Started</a></li><li><a class="toctext" href="../manual/variables.html">Variables</a></li><li><a class="toctext" href="../manual/integers-and-floating-point-numbers.html">Integers and Floating-Point Numbers</a></li><li><a class="toctext" href="../manual/mathematical-operations.html">Mathematical Operations and Elementary Functions</a></li><li><a class="toctext" href="../manual/complex-and-rational-numbers.html">Complex and Rational Numbers</a></li><li><a class="toctext" href="../manual/strings.html">Strings</a></li><li><a class="toctext" href="../manual/functions.html">Functions</a></li><li><a class="toctext" href="../manual/control-flow.html">Control Flow</a></li><li><a class="toctext" href="../manual/variables-and-scoping.html">Scope of Variables</a></li><li><a class="toctext" href="../manual/types.html">Types</a></li><li><a class="toctext" href="../manual/methods.html">Methods</a></li><li><a class="toctext" href="../manual/constructors.html">Constructors</a></li><li><a class="toctext" href="../manual/conversion-and-promotion.html">Conversion and Promotion</a></li><li><a class="toctext" href="../manual/interfaces.html">Interfaces</a></li><li><a class="toctext" href="../manual/modules.html">Modules</a></li><li><a class="toctext" href="../manual/documentation.html">Documentation</a></li><li><a class="toctext" href="../manual/metaprogramming.html">Metaprogramming</a></li><li><a class="toctext" href="../manual/arrays.html">Multi-dimensional Arrays</a></li><li><a class="toctext" href="../manual/linear-algebra.html">Linear algebra</a></li><li><a class="toctext" href="../manual/networking-and-streams.html">Networking and Streams</a></li><li><a class="toctext" href="../manual/parallel-computing.html">Parallel Computing</a></li><li><a class="toctext" href="../manual/dates.html">Date and DateTime</a></li><li><a class="toctext" href="../manual/interacting-with-julia.html">Interacting With Julia</a></li><li><a class="toctext" href="../manual/running-external-programs.html">Running External Programs</a></li><li><a class="toctext" href="../manual/calling-c-and-fortran-code.html">Calling C and Fortran Code</a></li><li><a class="toctext" href="../manual/handling-operating-system-variation.html">Handling Operating System Variation</a></li><li><a class="toctext" href="../manual/environment-variables.html">Environment Variables</a></li><li><a class="toctext" href="../manual/embedding.html">Embedding Julia</a></li><li><a class="toctext" href="../manual/packages.html">Packages</a></li><li><a class="toctext" href="../manual/profile.html">Profiling</a></li><li><a class="toctext" href="../manual/stacktraces.html">Stack Traces</a></li><li><a class="toctext" href="../manual/performance-tips.html">Performance Tips</a></li><li><a class="toctext" href="../manual/workflow-tips.html">Workflow Tips</a></li><li><a class="toctext" href="../manual/style-guide.html">Style Guide</a></li><li><a class="toctext" href="../manual/faq.html">Frequently Asked Questions</a></li><li><a class="toctext" href="../manual/noteworthy-differences.html">Noteworthy Differences from other Languages</a></li><li><a class="toctext" href="../manual/unicode-input.html">Unicode Input</a></li></ul></li><li><span class="toctext">Standard Library</span><ul><li><a class="toctext" href="../stdlib/base.html">Essentials</a></li><li><a class="toctext" href="../stdlib/collections.html">Collections and Data Structures</a></li><li><a class="toctext" href="../stdlib/math.html">Mathematics</a></li><li><a class="toctext" href="../stdlib/numbers.html">Numbers</a></li><li><a class="toctext" href="../stdlib/strings.html">Strings</a></li><li><a class="toctext" href="../stdlib/arrays.html">Arrays</a></li><li><a class="toctext" href="../stdlib/parallel.html">Tasks and Parallel Computing</a></li><li><a class="toctext" href="../stdlib/linalg.html">Linear Algebra</a></li><li><a class="toctext" href="../stdlib/constants.html">Constants</a></li><li><a class="toctext" href="../stdlib/file.html">Filesystem</a></li><li><a class="toctext" href="../stdlib/io-network.html">I/O and Network</a></li><li><a class="toctext" href="../stdlib/punctuation.html">Punctuation</a></li><li><a class="toctext" href="../stdlib/sort.html">Sorting and Related Functions</a></li><li><a class="toctext" href="../stdlib/pkg.html">Package Manager Functions</a></li><li><a class="toctext" href="../stdlib/dates.html">Dates and Time</a></li><li><a class="toctext" href="../stdlib/iterators.html">Iteration utilities</a></li><li><a class="toctext" href="../stdlib/test.html">Unit Testing</a></li><li><a class="toctext" href="../stdlib/c.html">C Interface</a></li><li><a class="toctext" href="../stdlib/libc.html">C Standard Library</a></li><li><a class="toctext" href="../stdlib/libdl.html">Dynamic Linker</a></li><li><a class="toctext" href="../stdlib/profile.html">Profiling</a></li><li><a class="toctext" href="../stdlib/stacktraces.html">StackTraces</a></li><li><a class="toctext" href="../stdlib/simd-types.html">SIMD Support</a></li></ul></li><li><span class="toctext">Developer Documentation</span><ul><li><a class="toctext" href="reflection.html">Reflection and introspection</a></li><li><span class="toctext">Documentation of Julia's Internals</span><ul><li><a class="toctext" href="init.html">Initialization of the Julia runtime</a></li><li><a class="toctext" href="ast.html">Julia ASTs</a></li><li><a class="toctext" href="types.html">More about types</a></li><li><a class="toctext" href="object.html">Memory layout of Julia Objects</a></li><li><a class="toctext" href="eval.html">Eval of Julia code</a></li><li><a class="toctext" href="callconv.html">Calling Conventions</a></li><li><a class="toctext" href="compiler.html">High-level Overview of the Native-Code Generation Process</a></li><li><a class="toctext" href="functions.html">Julia Functions</a></li><li><a class="toctext" href="cartesian.html">Base.Cartesian</a></li><li><a class="toctext" href="meta.html">Talking to the compiler (the <code>:meta</code> mechanism)</a></li><li><a class="toctext" href="subarrays.html">SubArrays</a></li><li><a class="toctext" href="sysimg.html">System Image Building</a></li><li><a class="toctext" href="llvm.html">Working with LLVM</a></li><li><a class="toctext" href="stdio.html">printf() and stdio in the Julia runtime</a></li><li><a class="toctext" href="boundscheck.html">Bounds checking</a></li><li><a class="toctext" href="locks.html">Proper maintenance and care of multi-threading locks</a></li><li><a class="toctext" href="offset-arrays.html">Arrays with custom indices</a></li><li><a class="toctext" href="libgit2.html">Base.LibGit2</a></li><li><a class="toctext" href="require.html">Module loading</a></li></ul></li><li><span class="toctext">Developing/debugging Julia's C code</span><ul><li><a class="toctext" href="backtraces.html">Reporting and analyzing crashes (segfaults)</a></li><li class="current"><a class="toctext" href="debuggingtips.html">gdb debugging tips</a><ul class="internal"><li><a class="toctext" href="#Displaying-Julia-variables-1">Displaying Julia variables</a></li><li><a class="toctext" href="#Useful-Julia-variables-for-Inspecting-1">Useful Julia variables for Inspecting</a></li><li><a class="toctext" href="#Useful-Julia-functions-for-Inspecting-those-variables-1">Useful Julia functions for Inspecting those variables</a></li><li><a class="toctext" href="#Inserting-breakpoints-for-inspection-from-gdb-1">Inserting breakpoints for inspection from gdb</a></li><li><a class="toctext" href="#Inserting-breakpoints-upon-certain-conditions-1">Inserting breakpoints upon certain conditions</a></li><li><a class="toctext" href="#Dealing-with-signals-1">Dealing with signals</a></li><li><a class="toctext" href="#Debugging-during-Julia's-build-process-(bootstrap)-1">Debugging during Julia's build process (bootstrap)</a></li><li><a class="toctext" href="#Debugging-precompilation-errors-1">Debugging precompilation errors</a></li><li><a class="toctext" href="#Mozilla's-Record-and-Replay-Framework-(rr)-1">Mozilla's Record and Replay Framework (rr)</a></li></ul></li><li><a class="toctext" href="valgrind.html">Using Valgrind with Julia</a></li><li><a class="toctext" href="sanitizers.html">Sanitizer support</a></li></ul></li></ul></li></ul></nav><article id="docs"><header><nav><ul><li>Developer Documentation</li><li>Developing/debugging Julia's C code</li><li><a href="debuggingtips.html">gdb debugging tips</a></li></ul><a class="edit-page" href="https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/debuggingtips.md"><span class="fa"></span> Edit on GitHub</a></nav><hr/><div id="topbar"><span>gdb debugging tips</span><a class="fa fa-bars" href="#"></a></div></header><h1><a class="nav-anchor" id="gdb-debugging-tips-1" href="#gdb-debugging-tips-1">gdb debugging tips</a></h1><h2><a class="nav-anchor" id="Displaying-Julia-variables-1" href="#Displaying-Julia-variables-1">Displaying Julia variables</a></h2><p>Within <code>gdb</code>, any <code>jl_value_t*</code> object <code>obj</code> can be displayed using</p><pre><code class="language-none">(gdb) call jl_(obj)</code></pre><p>The object will be displayed in the <code>julia</code> session, not in the gdb session. This is a useful way to discover the types and values of objects being manipulated by Julia's C code.</p><p>Similarly, if you're debugging some of Julia's internals (e.g., <code>inference.jl</code>), you can print <code>obj</code> using</p><pre><code class="language-julia">ccall(:jl_, Void, (Any,), obj)</code></pre><p>This is a good way to circumvent problems that arise from the order in which julia's output streams are initialized.</p><p>Julia's flisp interpreter uses <code>value_t</code> objects; these can be displayed with <code>call fl_print(fl_ctx, ios_stdout, obj)</code>.</p><h2><a class="nav-anchor" id="Useful-Julia-variables-for-Inspecting-1" href="#Useful-Julia-variables-for-Inspecting-1">Useful Julia variables for Inspecting</a></h2><p>While the addresses of many variables, like singletons, can be be useful to print for many failures, there are a number of additional variables (see <code>julia.h</code> for a complete list) that are even more useful.</p><ul><li><p>(when in <code>jl_apply_generic</code>) <code>mfunc</code> and <code>jl_uncompress_ast(mfunc->def, mfunc->code)</code> :: for figuring out a bit about the call-stack</p></li><li><p><code>jl_lineno</code> and <code>jl_filename</code> :: for figuring out what line in a test to go start debugging from (or figure out how far into a file has been parsed)</p></li><li><p><code>$1</code> :: not really a variable, but still a useful shorthand for referring to the result of the last gdb command (such as <code>print</code>)</p></li><li><p><code>jl_options</code> :: sometimes useful, since it lists all of the command line options that were successfully parsed</p></li><li><p><code>jl_uv_stderr</code> :: because who doesn't like to be able to interact with stdio</p></li></ul><h2><a class="nav-anchor" id="Useful-Julia-functions-for-Inspecting-those-variables-1" href="#Useful-Julia-functions-for-Inspecting-those-variables-1">Useful Julia functions for Inspecting those variables</a></h2><ul><li><p><code>jl_gdblookup($rip)</code> :: For looking up the current function and line. (use <code>$eip</code> on i686 platforms)</p></li><li><p><code>jlbacktrace()</code> :: For dumping the current Julia backtrace stack to stderr. Only usable after <code>record_backtrace()</code> has been called.</p></li><li><p><code>jl_dump_llvm_value(Value*)</code> :: For invoking <code>Value->dump()</code> in gdb, where it doesn't work natively. For example, <code>f->linfo->functionObject</code>, <code>f->linfo->specFunctionObject</code>, and <code>to_function(f->linfo)</code>.</p></li><li><p><code>Type->dump()</code> :: only works in lldb. Note: add something like <code>;1</code> to prevent lldb from printing its prompt over the output</p></li><li><p><code>jl_eval_string("expr")</code> :: for invoking side-effects to modify the current state or to lookup symbols</p></li><li><p><code>jl_typeof(jl_value_t*)</code> :: for extracting the type tag of a Julia value (in gdb, call <code>macro define jl_typeof jl_typeof</code> first, or pick something short like <code>ty</code> for the first arg to define a shorthand)</p></li></ul><h2><a class="nav-anchor" id="Inserting-breakpoints-for-inspection-from-gdb-1" href="#Inserting-breakpoints-for-inspection-from-gdb-1">Inserting breakpoints for inspection from gdb</a></h2><p>In your <code>gdb</code> session, set a breakpoint in <code>jl_breakpoint</code> like so:</p><pre><code class="language-none">(gdb) break jl_breakpoint</code></pre><p>Then within your Julia code, insert a call to <code>jl_breakpoint</code> by adding</p><pre><code class="language-julia">ccall(:jl_breakpoint, Void, (Any,), obj)</code></pre><p>where <code>obj</code> can be any variable or tuple you want to be accessible in the breakpoint.</p><p>It's particularly helpful to back up to the <code>jl_apply</code> frame, from which you can display the arguments to a function using, e.g.,</p><pre><code class="language-none">(gdb) call jl_(args[0])</code></pre><p>Another useful frame is <code>to_function(jl_method_instance_t *li, bool cstyle)</code>. The <code>jl_method_instance_t*</code> argument is a struct with a reference to the final AST sent into the compiler. However, the AST at this point will usually be compressed; to view the AST, call <code>jl_uncompress_ast</code> and then pass the result to <code>jl_</code>:</p><pre><code class="language-none">#2 0x00007ffff7928bf7 in to_function (li=0x2812060, cstyle=false) at codegen.cpp:584
|
|
584 abort();
|
|
(gdb) p jl_(jl_uncompress_ast(li, li->ast))</code></pre><h2><a class="nav-anchor" id="Inserting-breakpoints-upon-certain-conditions-1" href="#Inserting-breakpoints-upon-certain-conditions-1">Inserting breakpoints upon certain conditions</a></h2><h3><a class="nav-anchor" id="Loading-a-particular-file-1" href="#Loading-a-particular-file-1">Loading a particular file</a></h3><p>Let's say the file is <code>sysimg.jl</code>:</p><pre><code class="language-none">(gdb) break jl_load if strcmp(fname, "sysimg.jl")==0</code></pre><h3><a class="nav-anchor" id="Calling-a-particular-method-1" href="#Calling-a-particular-method-1">Calling a particular method</a></h3><pre><code class="language-none">(gdb) break jl_apply_generic if strcmp((char*)(jl_symbol_name)(jl_gf_mtable(F)->name), "method_to_break")==0</code></pre><p>Since this function is used for every call, you will make everything 1000x slower if you do this.</p><h2><a class="nav-anchor" id="Dealing-with-signals-1" href="#Dealing-with-signals-1">Dealing with signals</a></h2><p>Julia requires a few signal to function property. The profiler uses <code>SIGUSR2</code> for sampling and the garbage collector uses <code>SIGSEGV</code> for threads synchronization. If you are debugging some code that uses the profiler or multiple threads, you may want to let the debugger ignore these signals since they can be triggered very often during normal operations. The command to do this in GDB is (replace <code>SIGSEGV</code> with <code>SIGUSRS</code> or other signals you want to ignore):</p><pre><code class="language-none">(gdb) handle SIGSEGV noprint nostop pass</code></pre><p>The corresponding LLDB command is (after the process is started):</p><pre><code class="language-none">(lldb) pro hand -p true -s false -n false SIGSEGV</code></pre><p>If you are debugging a segfault with threaded code, you can set a breakpoint on <code>jl_critical_error</code> (<code>sigdie_handler</code> should also work on Linux and BSD) in order to only catch the actual segfault rather than the GC synchronization points.</p><h2><a class="nav-anchor" id="Debugging-during-Julia's-build-process-(bootstrap)-1" href="#Debugging-during-Julia's-build-process-(bootstrap)-1">Debugging during Julia's build process (bootstrap)</a></h2><p>Errors that occur during <code>make</code> need special handling. Julia is built in two stages, constructing <code>sys0</code> and <code>sys.ji</code>. To see what commands are running at the time of failure, use <code>make VERBOSE=1</code>.</p><p>At the time of this writing, you can debug build errors during the <code>sys0</code> phase from the <code>base</code> directory using:</p><pre><code class="language-none">julia/base$ gdb --args ../usr/bin/julia-debug -C native --build ../usr/lib/julia/sys0 sysimg.jl</code></pre><p>You might need to delete all the files in <code>usr/lib/julia/</code> to get this to work.</p><p>You can debug the <code>sys.ji</code> phase using:</p><pre><code class="language-none">julia/base$ gdb --args ../usr/bin/julia-debug -C native --build ../usr/lib/julia/sys -J ../usr/lib/julia/sys0.ji sysimg.jl</code></pre><p>By default, any errors will cause Julia to exit, even under gdb. To catch an error "in the act", set a breakpoint in <code>jl_error</code> (there are several other useful spots, for specific kinds of failures, including: <code>jl_too_few_args</code>, <code>jl_too_many_args</code>, and <code>jl_throw</code>).</p><p>Once an error is caught, a useful technique is to walk up the stack and examine the function by inspecting the related call to <code>jl_apply</code>. To take a real-world example:</p><pre><code class="language-none">Breakpoint 1, jl_throw (e=0x7ffdf42de400) at task.c:802
|
|
802 {
|
|
(gdb) p jl_(e)
|
|
ErrorException("auto_unbox: unable to determine argument type")
|
|
$2 = void
|
|
(gdb) bt 10
|
|
#0 jl_throw (e=0x7ffdf42de400) at task.c:802
|
|
#1 0x00007ffff65412fe in jl_error (str=0x7ffde56be000 <_j_str267> "auto_unbox:
|
|
unable to determine argument type")
|
|
at builtins.c:39
|
|
#2 0x00007ffde56bd01a in julia_convert_16886 ()
|
|
#3 0x00007ffff6541154 in jl_apply (f=0x7ffdf367f630, args=0x7fffffffc2b0, nargs=2) at julia.h:1281
|
|
...</code></pre><p>The most recent <code>jl_apply</code> is at frame #3, so we can go back there and look at the AST for the function <code>julia_convert_16886</code>. This is the uniqued name for some method of <code>convert</code>. <code>f</code> in this frame is a <code>jl_function_t*</code>, so we can look at the type signature, if any, from the <code>specTypes</code> field:</p><pre><code class="language-none">(gdb) f 3
|
|
#3 0x00007ffff6541154 in jl_apply (f=0x7ffdf367f630, args=0x7fffffffc2b0, nargs=2) at julia.h:1281
|
|
1281 return f->fptr((jl_value_t*)f, args, nargs);
|
|
(gdb) p f->linfo->specTypes
|
|
$4 = (jl_tupletype_t *) 0x7ffdf39b1030
|
|
(gdb) p jl_( f->linfo->specTypes )
|
|
Tuple{Type{Float32}, Float64} # <-- type signature for julia_convert_16886</code></pre><p>Then, we can look at the AST for this function:</p><pre><code class="language-none">(gdb) p jl_( jl_uncompress_ast(f->linfo, f->linfo->ast) )
|
|
Expr(:lambda, Array{Any, 1}[:#s29, :x], Array{Any, 1}[Array{Any, 1}[], Array{Any, 1}[Array{Any, 1}[:#s29, :Any, 0], Array{Any, 1}[:x, :Any, 0]], Array{Any, 1}[], 0], Expr(:body,
|
|
Expr(:line, 90, :float.jl)::Any,
|
|
Expr(:return, Expr(:call, :box, :Float32, Expr(:call, :fptrunc, :Float32, :x)::Any)::Any)::Any)::Any)::Any</code></pre><p>Finally, and perhaps most usefully, we can force the function to be recompiled in order to step through the codegen process. To do this, clear the cached <code>functionObject</code> from the <code>jl_lamdbda_info_t*</code>:</p><pre><code class="language-none">(gdb) p f->linfo->functionObject
|
|
$8 = (void *) 0x1289d070
|
|
(gdb) set f->linfo->functionObject = NULL</code></pre><p>Then, set a breakpoint somewhere useful (e.g. <code>emit_function</code>, <code>emit_expr</code>, <code>emit_call</code>, etc.), and run codegen:</p><pre><code class="language-none">(gdb) p jl_compile(f)
|
|
... # your breakpoint here</code></pre><h2><a class="nav-anchor" id="Debugging-precompilation-errors-1" href="#Debugging-precompilation-errors-1">Debugging precompilation errors</a></h2><p>Module precompilation spawns a separate Julia process to precompile each module. Setting a breakpoint or catching failures in a precompile worker requires attaching a debugger to the worker. The easiest approach is to set the debugger watch for new process launches matching a given name. For example:</p><pre><code class="language-none">(gdb) attach -w -n julia-debug</code></pre><p>or:</p><pre><code class="language-none">(lldb) process attach -w -n julia-debug</code></pre><p>Then run a script/command to start precompilation. As described earlier, use conditional breakpoints in the parent process to catch specific file-loading events and narrow the debugging window. (some operating systems may require alternative approaches, such as following each <code>fork</code> from the parent process)</p><h2><a class="nav-anchor" id="Mozilla's-Record-and-Replay-Framework-(rr)-1" href="#Mozilla's-Record-and-Replay-Framework-(rr)-1">Mozilla's Record and Replay Framework (rr)</a></h2><p>Julia now works out of the box with <a href="http://rr-project.org/">rr</a>, the lightweight recording and deterministic debugging framework from Mozilla. This allows you to replay the trace of an execution deterministically. The replayed execution's address spaces, register contents, syscall data etc are exactly the same in every run.</p><p>A recent version of rr (3.1.0 or higher) is required.</p><footer><hr/><a class="previous" href="backtraces.html"><span class="direction">Previous</span><span class="title">Reporting and analyzing crashes (segfaults)</span></a><a class="next" href="valgrind.html"><span class="direction">Next</span><span class="title">Using Valgrind with Julia</span></a></footer></article></body></html>
|