KDevelop5/Manual/Debugging programs/da: Difference between revisions

From KDE UserBase Wiki
(Importing a new version from external source)
 
(Updating to match new version of source page)
 
(18 intermediate revisions by 2 users not shown)
Line 1: Line 1:
<languages />
<languages />


== Debugging programs in KDevelop ==
== Fejlsøgning af programmer i KDevelop ==
<span id="Running a program in the debugger"></span>
<span id="Running a program in the debugger"></span>
=== Running a program in the debugger ===
=== Kør et program i fejlsøgeren ===


Once you have a launch configured (see [[Special:myLanguage/KDevelop5/Manual/Running programs|Running programs]]), you can also run it in a debugger: Select the menu item <menuchoice>Run -> Debug Launch</menuchoice>, or hit <keycap>F9</keycap>. If you are familiar with '''gdb''', the effect is the same as starting '''gdb''' with the executable specified in the launch configuration and then saying <code>Run</code>. This means that if the program calls <code>abort()</code> somewhere (e.g. when you run onto a failing assertion) or if there is a segmentation fault, then the debugger will stop. On the other hand, if the program runs to the end (with or without doing the right thing) then the debugger will not stop by itself before the program is finished. In the latter case, you will want to set a breakpoint on all those lines of your code base where you want the debugger to stop before you run the debug launch. You can do that by moving the cursor on such a line and selecting the menu item <menuchoice>Run -> Toggle breakpoint</menuchoice>, or right-clicking on a line and selecting <menuchoice>Toggle Breakpoint</menuchoice> from the context menu.
Når du har konfigureret en opstarter (se [[Special:myLanguage/KDevelop5/Manual/Running programs|Kør programmer]]), så kan du også køre det i fejlsøgeren: Vælg menuen <menuchoice>Kør -> Start fejlsøger</menuchoice> eller tast <keycap>F9</keycap>. Hvis du er fortrolig med '''gdb''', så er effekten den samme som at starte '''gdb''' med den kørbare fil specificeret i opstartskonfigurationen og så sige <code>Run</code>. Dette betyder, at hvis programmet et eller andet sted kalder <code>abort()</code> (fx hvis det støder på en "assertion", som ikke passer) eller hvis der forekommer en segmenteringsfejl, så vil debuggeren stoppe. Hvis programmet på den anden side kører indtil det er færdigt (hvadenten det løser sin opgave rigtigt eller ej), så vil fejlsøgeren ikke stoppe af sig selv før programmet er færdigt. I dette tilfælde har du brug for sætte et stoppunkt på alle de linjer i din kodebase, hvor du vil have fejlsøgeren til at stoppe, før du starter fejlsøgeren. Du kan gøre dette ved at placere markøren på en sådan linje og vælge menuen <menuchoice>Kør -> Slå stoppunkt til/fra</menuchoice> eller højreklikke på linjen og vælge <menuchoice>Slå stoppunkt til/fra</menuchoice> i kontekstmenuen.


<div class="mw-translate-fuzzy">
[[Image:kdevelop-4.png|center|thumb|550px]]
[[Image:kdevelop-4.png|center|thumb|550px]]
</div>


Running a program in the debugger will put '''KDevelop''' in a different mode: it will replace all the "Tool" buttons on the perimeter of the main window by ones that are appropriate for debugging, rather than for editing. You can see which of the mode you are in by looking at the top right of the window: there are tabs named <menuchoice>Review</menuchoice>, <menuchoice>Debug</menuchoice>, and <menuchoice>Code</menuchoice>; clicking on them allows you to switch back and forth between the three modes; each mode has a set of tool views of its own, which you can configure in the same way as we configured the <menuchoice>Code</menuchoice> tools in the section [[KDevelop5/Manual/Working_with_source_code#Tools and views|Tools and views]].
<div class="mw-translate-fuzzy">
Når du kører er program i fejlsøgeren, så kommer '''KDevelop''' i  en anden tilstand: den vil erstatte værktøjsknapperne i hovedvinduets kant med nogle, som har med fejlsøgning snarere end redigering at gøre. Du kan se, hvilken tilstand du er i øverst til højre i vinduet: der er fanebladene <menuchoice>Eftersyn</menuchoice>, <menuchoice>Fejlsøgning</menuchoice> og <menuchoice>Kode</menuchoice>; ved at klikke på dem kan du skifte imellem de tre forskellige tilstande; hver tilstand har sit eget sæt værktøjer, som kan konfigureres på samme måde, som du gjorde med værktøjerne i <menuchoice>Kode</menuchoice> i afsnittet om [[KDevelop5/Manual/Working_with_source_code#Tools and views|Værktøjer og visninger]].
</div>


Once the debugger stops (at a breakpoint, or a point where <code>abort()</code> is called) you can inspect a variety of information about your program. For example, in the image above, we have selected the <menuchoice>Frame Stack</menuchoice> tool at the bottom (roughly equivalent to '''gdb's''' "backtrace" and "info threads" commands) that shows the various threads that are currently running in your program at the left (here a total of 8) and how execution got to the current stopping point at the right (here: <code>main()</code> called <code>run()</code>; the list would be longer had we stopped in a function called by <code>run()</code> itself). On the left, we can inspect local variables including the current object (the object pointed to by the <code>this</code> variable).
<div class="mw-translate-fuzzy">
Nå fejlsøgeren standser (ved et stoppunkt eller et sted, hvor <code>abort()</code> kaldes) kan du få forskellig slags information om dit program. I billedet ovenfor har vi for eksempel valgt værktøjet <menuchoice>Frame Stack</menuchoice> for neden i vinduet (det svarer nogenlunde til '''gdb's''' kommandoer "backtrace" og "info threads"), som til venstre viser de forskellige tråde, som i øjeblikket kører i dit program (der er i alt 8) og til højre, hvordan udførslen kom til det aktuelle stoppunkt (her blev <code>run()</code> kaldt fra <code>main()</code>; listen ville være længere, hvis vi var stoppet i en funktion kaldt fra <code>run()</code> selv). Til venstre kan vi inspicere lokale variable, herunder det aktuelle objekt (det objekt, som variablen <code>this</code> henviser til).
</div>


From here, there are various possibilities you can do: You can execute the current line (<keycap>F10</keycap>, '''gdb's''' "next" command), step into the functions (<keycap>F11</keycap>, '''gdb's''' "step" command), or run to the end of the function (<keycap>F12</keycap>, '''gdb's''' "finish" command). At every stage, '''KDevelop''' updates the variables shown at the left to their current values. You can also hover the mouse over a symbol in your code, e.g. a variable; '''KDevelop''' will then show the current value of that symbol and offer to stop the program during execution the next time this variable's value changes. If you know '''gdb''', you can also click on the <menuchoice>GDB</menuchoice> tool button at the bottom and have the possibility to enter '''gdb''' commands, for example in order to change the value of a variable (for which there doesn't currently seem to be another way).
Herfra her du flere muligheder: Du kan udføre den aktuelle linje (<keycap>F10</keycap>, '''gdb's''' kommando "next") eller gå ind i funktionen (<keycap>F12</keycap>, '''gdb's''' kommando "finish"). '''KDevelop''' vil hele tiden opdatere de variable, som vises til venstre til deres aktuelle værdier. Du kan også lade musen svæve over et symbol i koden, fx en variabel; '''KDevelop''' vil så vise den aktuelle værdi af symbolet og give dig mulighed for at stoppe programmet, næste gang symbolets værdi ændres. Hvis du kender '''gdb''', så kan du også klikke på værktøjsknappen <menuchoice>GDB</menuchoice> for neden og få mulighed for at skrive '''gdb'''-kommandoer, for eksempel for at ændre værdien af en variabel (hvilke i øjeblikket ikke kan gøres på andre måder).
<span id="Attaching the debugger to a running process"></span>
<span id="Attaching the debugger to a running process"></span>
=== Attaching the debugger to a running process ===
=== Knyt fejlsøgeren til en kørende proces ===


<div class="mw-translate-fuzzy">
[[Image:kdevelop-9.png|center|thumb|300px]]
[[Image:kdevelop-9.png|center|thumb|300px]]
</div>


Sometimes, one wants to debug a program that's already running. One scenario for this is debugging parallel programs using [https://computing.llnl.gov/tutorials/mpi/ MPI], or for debugging a long running background process. To do this, go to the menu entry <menuchoice>Run -> Attach to Process</menuchoice>, which will open a window like the one above. You will want to select the program that matches your currently open project in '''KDevelop''' - in my case that would be the step-32 program.  
<div class="mw-translate-fuzzy">
Undertiden har man brug for at søge efter fejl i et program, som allerede kører; for eksempel når man fejlsøger parallelle programmer med [https://computing.llnl.gov/tutorials/mpi/ MPI] eller baggrundsprocesser, som kører i lang tid. For at gøre dette vælger du menuen <menuchoice>Kør -> Knyt til proces</menuchoice>, hvorved et vindue som ovenfor åbnes. Du skal vælge det program, som passer med det projekt, som du aktuelt har åbent i '''KDevelop''' &mdash; i mit tilfælde er det programmet step-32.
</div>


This list of programs can be confusing because it is often long as in the case shown here. You can make your life a bit easier by going to the dropdown box at the top right of the window. The default value is <menuchoice>User processes</menuchoice>, i.e. all programs that are run by any of the users currently logged into this machine (if this is your desktop or laptop, you're probably the only such user, apart from root and various service accounts); the list doesn't include processes run by the root user, however. You can limit the list by either choosing <menuchoice>Own processes</menuchoice>, removing all the programs run by other users. Or better still: Select <menuchoice>Programs only</menuchoice>, which removes a lot of processes that are formally running under your name but that you don't usually interact with, such as the window manager, background tasks and so on that are unlikely candidates for debugging.
[[File:Kdevelop-attach-to-process-refuse.png|500px|thumb|center]]


Once you have selected a process, attaching to it will get you into '''KDevelop's''' debug mode, open all the usual debugger tool views and stop the program at the position where it happened to be when you attached to it. You may then want to set breakpoints, viewpoints, or whatever else is necessary and continue program execution by going to the menu item <menuchoice>Run -> Continue</menuchoice>.
Attaching a debugger to a running program is not allowed by default on most
Linux distributions. To do so, you first need to know a little about
''PTRACE'' system that is used for debugging. Generally, the default setting is a
scope of "1", which limits PTRACE to direct child processes only (e.g. "gdb
name-of-program" and "strace -f name-of-program" work, but gdb's "attach"
and "strace -fp $PID" do not). A PTRACE scope of "0" is the more permissive
mode.
 
There are two ways to change this on Ubuntu, if you are running a different distribution, your requirements may be different. On Ubuntu, one way is to edit the  
<tt>/etc/sysctl.d/10-ptrace.conf</tt> file and change <tt>kernel.yama.ptrace_scope</tt> to 0.
After editing the file run the following command:
{{Input|1=<nowiki>sudo service procps restart</nowiki>}} You should now be able to attach to a running process.
 
The other way that is the more secure way is to run:
{{Input|1=<nowiki>echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope</nowiki>}}
when you want to use the feature, and:
{{Input|1=<nowiki>echo 1 | sudo tee /proc/sys/kernel/yama/ptrace_scope</nowiki>}}
when you have completed your need for attaching to a running process.
 
After setting your <tt>ptrace_scope</tt> to 0, you will want to select the program that matches your currently open project in '''KDevelop'''.
 
Listen af programmer kan være forvirrende, fordi den ofte er lang som i eksemplet ovenfor. Du kan gøre livet lettere for dig selv ved at bruge dropnedlisten foroven til højre i vinduet. Standardværdien er <menuchoice>Brugerprocesser</menuchoice>, dvs. alle programmer, som køres af en af de brugere, der aktuelt er logget ind på maskinen (hvis det er din personlige computer, så er du nok den eneste bruger, bortset fra root og forskellige tjenester); listen inkluderer dog ikke processer, som køres af root-brugeren. Du kan begrænse listen ved enten at vælge <menuchoice>Egne processer</menuchoice> og derved fjerne alle programmer, som andre brugere kører; eller endnu bedre, vælg <menuchoice>Kun programmer</menuchoice>, hvilket fjerner en masse processer, som formelt kører under dit navn, men som du normalt ikke arbejder direkte med &mdash; vinduesmanageren, baggrundsopgaver og så videre &mdash; og som du normalt ikke vil søge fejl i.
 
Når du har valgt en proces og knyttet '''KDevelop''' til den, så kommer du i fejlsøgningstilstand med alle de sædvanlige fejlsøgningsværktøjer; og programmet stopper der, hvor det var, da du knyttede dig til det. Nu kan du sætte stoppunkter, visningspunkter og hvad du ellers har brug for og derefter lade programmet fortsætte ved at vælge menuen <menuchoice>Kør -> Fortsæt</menuchoice>.
<span id="Some useful keyboard shortcuts"></span>
<span id="Some useful keyboard shortcuts"></span>
=== Some useful keyboard shortcuts ===
=== Nogle nyttig tastaturgenveje ===


{| class="tablecenter" style="border:1px solid"
{| class="tablecenter" style="border:1px solid"
! colspan="2" style="background:#ffff99;" | Debugging
! colspan="2" style="background:#ffff99;" | Fejlsøgning
|-
|-


| F10  
| F10  
| Step over (gdb's "next")
| over (gdb's "next")
|-
|-


| F11  
| F11  
| Step into (gdb's "step")
| Gå ind i (gdb's "step")
|-
|-


| F12
| F12
| Step out of (gdb's "finish")
| Gå ud (gdb's "finish")
|}
|}


{{Prevnext2
{{Prevnext2
| prevpage=Special:MyLanguage/KDevelop5/Manual/Running_programs | nextpage=Special:MyLanguage/KDevelop5/Manual/Working_with_version_control_systems
| prevpage=Special:MyLanguage/KDevelop5/Manual/Running_programs | nextpage=Special:MyLanguage/KDevelop5/Manual/Working_with_version_control_systems
| prevtext=Running programs | nexttext=Working with version control systems
| prevtext=Kør programmer | nexttext=Arbejdet med versionskontrolsystemer
| index=Special:MyLanguage/KDevelop5/Manual | indextext=Back to menu
| index=Special:MyLanguage/KDevelop5/Manual | indextext=Indholdsfortegnelse
}}
}}


[[Category:Development]]
[[Category:Udvikling/da]]

Latest revision as of 14:54, 7 September 2020

Other languages:

Fejlsøgning af programmer i KDevelop

Kør et program i fejlsøgeren

Når du har konfigureret en opstarter (se Kør programmer), så kan du også køre det i fejlsøgeren: Vælg menuen Kør -> Start fejlsøger eller tast F9. Hvis du er fortrolig med gdb, så er effekten den samme som at starte gdb med den kørbare fil specificeret i opstartskonfigurationen og så sige Run. Dette betyder, at hvis programmet et eller andet sted kalder abort() (fx hvis det støder på en "assertion", som ikke passer) eller hvis der forekommer en segmenteringsfejl, så vil debuggeren stoppe. Hvis programmet på den anden side kører indtil det er færdigt (hvadenten det løser sin opgave rigtigt eller ej), så vil fejlsøgeren ikke stoppe af sig selv før programmet er færdigt. I dette tilfælde har du brug for sætte et stoppunkt på alle de linjer i din kodebase, hvor du vil have fejlsøgeren til at stoppe, før du starter fejlsøgeren. Du kan gøre dette ved at placere markøren på en sådan linje og vælge menuen Kør -> Slå stoppunkt til/fra eller højreklikke på linjen og vælge Slå stoppunkt til/fra i kontekstmenuen.

Når du kører er program i fejlsøgeren, så kommer KDevelop i en anden tilstand: den vil erstatte værktøjsknapperne i hovedvinduets kant med nogle, som har med fejlsøgning snarere end redigering at gøre. Du kan se, hvilken tilstand du er i øverst til højre i vinduet: der er fanebladene Eftersyn, Fejlsøgning og Kode; ved at klikke på dem kan du skifte imellem de tre forskellige tilstande; hver tilstand har sit eget sæt værktøjer, som kan konfigureres på samme måde, som du gjorde med værktøjerne i Kode i afsnittet om Værktøjer og visninger.

Nå fejlsøgeren standser (ved et stoppunkt eller et sted, hvor abort() kaldes) kan du få forskellig slags information om dit program. I billedet ovenfor har vi for eksempel valgt værktøjet Frame Stack for neden i vinduet (det svarer nogenlunde til gdb's kommandoer "backtrace" og "info threads"), som til venstre viser de forskellige tråde, som i øjeblikket kører i dit program (der er i alt 8) og til højre, hvordan udførslen kom til det aktuelle stoppunkt (her blev run() kaldt fra main(); listen ville være længere, hvis vi var stoppet i en funktion kaldt fra run() selv). Til venstre kan vi inspicere lokale variable, herunder det aktuelle objekt (det objekt, som variablen this henviser til).

Herfra her du flere muligheder: Du kan udføre den aktuelle linje (F10, gdb's kommando "next") eller gå ind i funktionen (F12, gdb's kommando "finish"). KDevelop vil hele tiden opdatere de variable, som vises til venstre til deres aktuelle værdier. Du kan også lade musen svæve over et symbol i koden, fx en variabel; KDevelop vil så vise den aktuelle værdi af symbolet og give dig mulighed for at stoppe programmet, næste gang symbolets værdi ændres. Hvis du kender gdb, så kan du også klikke på værktøjsknappen GDB for neden og få mulighed for at skrive gdb-kommandoer, for eksempel for at ændre værdien af en variabel (hvilke i øjeblikket ikke kan gøres på andre måder).

Knyt fejlsøgeren til en kørende proces

Undertiden har man brug for at søge efter fejl i et program, som allerede kører; for eksempel når man fejlsøger parallelle programmer med MPI eller baggrundsprocesser, som kører i lang tid. For at gøre dette vælger du menuen Kør -> Knyt til proces, hvorved et vindue som ovenfor åbnes. Du skal vælge det program, som passer med det projekt, som du aktuelt har åbent i KDevelop — i mit tilfælde er det programmet step-32.

Attaching a debugger to a running program is not allowed by default on most Linux distributions. To do so, you first need to know a little about PTRACE system that is used for debugging. Generally, the default setting is a scope of "1", which limits PTRACE to direct child processes only (e.g. "gdb name-of-program" and "strace -f name-of-program" work, but gdb's "attach" and "strace -fp $PID" do not). A PTRACE scope of "0" is the more permissive mode.

There are two ways to change this on Ubuntu, if you are running a different distribution, your requirements may be different. On Ubuntu, one way is to edit the /etc/sysctl.d/10-ptrace.conf file and change kernel.yama.ptrace_scope to 0. After editing the file run the following command:

sudo service procps restart

You should now be able to attach to a running process.

The other way that is the more secure way is to run:

echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope

when you want to use the feature, and:

echo 1 | sudo tee /proc/sys/kernel/yama/ptrace_scope

when you have completed your need for attaching to a running process.

After setting your ptrace_scope to 0, you will want to select the program that matches your currently open project in KDevelop.

Listen af programmer kan være forvirrende, fordi den ofte er lang som i eksemplet ovenfor. Du kan gøre livet lettere for dig selv ved at bruge dropnedlisten foroven til højre i vinduet. Standardværdien er Brugerprocesser, dvs. alle programmer, som køres af en af de brugere, der aktuelt er logget ind på maskinen (hvis det er din personlige computer, så er du nok den eneste bruger, bortset fra root og forskellige tjenester); listen inkluderer dog ikke processer, som køres af root-brugeren. Du kan begrænse listen ved enten at vælge Egne processer og derved fjerne alle programmer, som andre brugere kører; eller endnu bedre, vælg Kun programmer, hvilket fjerner en masse processer, som formelt kører under dit navn, men som du normalt ikke arbejder direkte med — vinduesmanageren, baggrundsopgaver og så videre — og som du normalt ikke vil søge fejl i.

Når du har valgt en proces og knyttet KDevelop til den, så kommer du i fejlsøgningstilstand med alle de sædvanlige fejlsøgningsværktøjer; og programmet stopper der, hvor det var, da du knyttede dig til det. Nu kan du sætte stoppunkter, visningspunkter og hvad du ellers har brug for og derefter lade programmet fortsætte ved at vælge menuen Kør -> Fortsæt.

Nogle nyttig tastaturgenveje

Fejlsøgning
F10 Gå over (gdb's "next")
F11 Gå ind i (gdb's "step")
F12 Gå ud (gdb's "finish")