Support "set-next-statement" with cppdbg

[akbyrd]

The ability to modify the instruction pointer to point a different location without running any code is an extremely useful debugging feature in C/C++. I'd like to request this feature in the toolset.

Visual Studio has an implementation of this, referred to as "Set Next Statement" in the UI. It is normally done by either dragging the yellow arrow indicating the currently executing line of code, or by right clicking a line and choosing "Set Next Statement". https://msdn.microsoft.com/en-us/library/y740d9d3.aspx#Anchor_4

It appears the protocol for this is already implemented in VS Code. https://github.com/Microsoft/vscode-debugadapter-node/issues/28 https://github.com/Microsoft/vscode-debugadapter-node/pull/45

Related: https://github.com/Microsoft/vscode/issues/12514

[pieandcakes]

@akbyrd AFAIK gdb/lldb does not support anything like this today.

[akbyrd]

@pieandcakes I've not used them personally, but after a few searches it appears this capability exists in GDB and LLDB.

In GDB it's enabled by the jump command: https://sourceware.org/gdb/current/onlinedocs/gdb/Jumping.html#Jumping

jump location Resume execution at location. The most common occasion to use the jump command is to back up—perhaps with more breakpoints set—over a portion of a program that has already executed, in order to examine its execution in more detail.

Thread where support for this was implemented in another IDE (also contains a link to a patch for another IDE with implementation) http://forums.codeblocks.org/index.php?topic=10064.0

The LLDB manual explicitly gives an equivalent to the GDB jump command: https://lldb.llvm.org/lldb-gdb.html

Skip 8 bytes ahead of the current program counter (instruction pointer). Note that we use backticks to evaluate an expression and insert the scalar result in LLDB. (gdb) jump *$pc+8 | (lldb) register write pc $pc+8

And the repo actually has a script extension to make it look more like GDB jump: https://github.com/llvm-mirror/lldb/blob/master/examples/python/jump.py

Provided I haven't misunderstood the purpose of the above command it would appear "set next statement" type behavior is well supported and fairly well used considering the amount of search hits.

[pieandcakes]

@akbyrd Thank you for the information. We need to use gdb's MI mode to drive the debugger and I was able to find this:

The -exec-jump Command

Synopsis

 -exec-jump location

Resumes execution of the inferior program at the location specified by parameter. See Specify Location, for a description of the different forms of location. 

GDB Command

The corresponding GDB command is ‘jump’. 

Example

-exec-jump foo.c:10
*running,thread-id="all"
^running

[kostyamy]

i understand it cold be kinda off-topic but any idea about similar feature in c# debugger? should i reference some other group?

the feature by itself is one of they key tools while developing complex apis what require setting up a complex context for each call. As result ability to "re-walk" over and over again same code instance while modifying internal variables from the console becomes a huge time saver.

[akbyrd]

@kostyamy I would assume creating an issue in the C# repo and referencing this issue and the protocol implementation issue would be the best course of action.

[kostyamy]

@akbyrd it makes total sense but i bit confused what C# repo is? is that https://github.com/OmniSharp/omnisharp-vscode or there is something like https://github.com/Microsoft/vscode-csharp ???

[akbyrd]

It looks like the OmniSharp repo is the official one

[kostyamy]

@akbyrd i just made a post there and referenced this issue. so thank you. hopefully they move fast enough

[andreassolemkjaer]

Any update on this? This is the one feature missing from moving exclusively to VScode.

[stephanreiter]

I'd love to see this implemented. I need to use this occasionally and then always return to regular Visual Studio in frustration.

[BeBopping]

I agree with others here. This is one of the most powerful debuging features that I use in VS, and it really needs to be added to VSCode if at all possible..

[TanWei]

I wonder if this feature has been added or is in development.

[ntoskrnl7]

@BeBopping @TanWei @stephanreiter

Install the vsc extension of the link below.

https://marketplace.visualstudio.com/items?itemName=ntoskrnl7.cxx-set-next-statement-extension

It works well in cppvsdbg (vscode-cpptools -OpenDebugAD7). However, GDB requires the following VSC extension(Debug Adapter) to be installed. https://github.com/ntoskrnl7/code-debug/tree/support_gdb_goto_request

enjoy :)

[ilqvya]

Lol, gdb and lldb already support it

gdb

jump 10

10 is a code line

Plz, add support for native gcc and lldb. Also add ability to write commandline commands together with UI

[msimic]

@akbyrd AFAIK gdb/lldb does not support anything like this today.

this is completely false, both gdb and lldb support this

[aallrd]

Hello, We also need this feature in order to be able to properly debug on Visual Studio Code as we do on Visual Studio. I understand that there is no "set next statement" method yet in the UI, but I tried to manually issue the -exec-jump foo.c:10 command in the Visual Studio Code debug console and it failed, is it expected?

[aallrd]

@pieandcakes, from your previous reply, can you please confirm if the command -exec-jump foo.c:10 issued in the Visual Studio Code debug console (GDB) is expected to fail?

[SavitaMaurya]

Hi team, Any update on this? Would be really nice to see this feature working in VSCode. I also come Visual Studio world.

[sean-mcmanus]

FYI, this feature works on Windows with cppvsdbg mode, but not cppdbg mode (any OS).

[FabianoGK]

@pieandcakes, from your previous reply, can you please confirm if the command -exec-jump foo.c:10 issued in the Visual Studio Code debug console (GDB) is expected to fail?

The -exec-jump command can be executed from the Visual Studio Code debug console using cppdbg:

-exec -exec-jump foo.c:140
result-class: running

Note that Set Next Statement is a combination of temporary breakpoint (-exec-break -t) and jump (-exec-jump):

-exec -break-insert -t foo.c:140
result-class: done
bkpt: {number=12,type=breakpoint,disp=del,enabled=y,addr=0x000578d6,func=main(int, char**),file=foo.c,fullname=src/foo.c,line=140,thread-groups=[i1],times=0,original-location=foo.c:140}

-exec -exec-jump foo.c:140
result-class: running

Temporary breakpoint 12, main (argc=1, argv=0xbefffdf4) at foo.c:140
140     tid = syscall(SYS_gettid);
=breakpoint-deleted,id="12"

The new location is not updated in the UI. In fact, it throws an exception:

If you step over after that, it does show the proper next line in the UI.

I'm really looking forward to having this feature fully supported!

[ilqvya]

Where I can see the full list of VSCode dbg commands ?

[FabianoGK]

@effolkronium add this to your launch.json configuration:

            "logging": {
                "engineLogging": true
            }

The commands will be shown in the VSCode Debug Console.

[hsandt]

@ntoskrnl7

I know this is not directly related to vscode native state and therefore a bit out of topic, but that's my only track for a workaround for now, and besides ntoskrnl7's repositories lack an Issue section so I cannot post an issue there instead. In addition, nobody commented on this plugin yet, so people reading this thread may be interested to know if the workaround can work.

Install the vsc extension of the link below.

https://marketplace.visualstudio.com/items?itemName=ntoskrnl7.cxx-set-next-statement-extension

It works well in cppvsdbg (vscode-cpptools -OpenDebugAD7). However, GDB requires the following VSC extension(Debug Adapter) to be installed. https://github.com/ntoskrnl7/code-debug/tree/support_gdb_goto_request

enjoy :)

I installed the .vsix for both Native-Debug and CodeLLDB, then ntoskrnl7.cxx-set-next-statement-extension, and I see the new item Set Next Statement (C/C++), but it still pops an error:

Unable to set the next statement. Error: Set next statement is not supported by the current debugger.

Maybe it's because I'm using MI? My launch config uses this:

        "type": "cppdbg",
        "MIMode": "gdb",

so I guess I must install MIEngine, but there is no .vsix for it provided in https://github.com/ntoskrnl7/cxx-set-next-statement-extension/tree/master/extensions. I guess I could build it from the repo, but I'm not familiar with the extension build process.

Alternatively I could use something else than MI, but I don't know how to use something else. Removing the line with MIMode doesn't change anything, it seems like VS Code is just using MI by default.

So in the current state, I don't have a native solution nor a workaround.

[aallrd]

Hello, Is there any update on the availability of this feature? Is it planned for a next release?

[MatthewForrester]

This functionality is taught in lesson 3.7 of the popular LearnCPP.com tutorial for C++. That means that these features are regarded as basic tools for elementary C++ debugging, not an advanced or esoteric features. So I really hope that a kind contributor will be able to finish this work.

[amurzeau]

As a workaround, one can do this instead:

• Set a breakpoint on the line where to set the current PC cursor on
• Run the following command in the Debugger Console panel: -exec jump <line> where line is the line number in the source code.

[g-fleming]

Is this still not supported? "Set next statement" doesn't work for me when using g++ and gdb in VScode with WSL linux remote debugging. It would be extremely helpful to be backstep and iterate through same code.

I can go to Debug Console in Vscode while stopped at breakpoint and type gdb command: -exec jump line

And it works. So it seems the gdb command just needs to be linked somehow to right click line -> Jump to Cursor in the UI.