int i = 2; // what do you use as a throwaway line when you just need something to breakpoint on?

Question

Whenever I want a breakpoint someplace where there isnt anything to break on just (inside a loop, &c), I tend to automatically drop down a:

int i = 2;

I'm curious what others use.

Answer 1

console.write("stop here")

In .net always use exactly that line, I have no idea why, just have for years.

Answer 2

Visual Studio lets you break on a brace.

Answer 3

In C#, I break on the end brace, and in VB.NET I break on the End If/Sub/Function/whatever.

Answer 4

Console.Writeline(e.Message);

Answer 5

bool breakHere = true;

It's self-documenting!

Answer 6

(void *)"Insert witty comment."

Answer 7

If it's C++ on a x86 machine, I just use:

__asm int 3

and just wait for the exception to hit. Don't even have to start in the debugger on Windows, or you use good ole DebugBreak().

Answer 8

asm { int3 }

But i'm a crazy person :D

Answer 9

In the .NET Framework (using C# here):

System.Diagnostics.Debugger.Break();

To avoid typing this every time just create a new code snippet for your preferred language:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet"&gt;
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>sddb</Title>
      <Shortcut>sddb</Shortcut>
      <Description>
        Code snippet for System.Diagnostics.Debugger.Break()
      </Description>
      <Author>Peter McGrattan</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Code Language="csharp">
        <![CDATA[System.Diagnostics.Debugger.Break();$end$]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Answer 10

I do the same thing with the int value but my favorite is "int y=1;".

Answer 11

i = i;

or any variable defined in the scope.

In C#/VS you get a compiler warning, so it's also a good method to mark code as not finished etc.

Answer 12

String foo = "bar";

Answer 13

int moo = 42;

Why moo? Don't know, it just springs to mind. Why 42? Why wouldn't you pick it!

Answer 14

int x = 0;  
x = x;

Answer 15

What's the point of inserting code to break? Isn't there already code where you want to break? I just put the breakpoint on the actual line in question; my IDE (Eclipse) stops before executing that line. Seems easy enough.

Now, before I learned about conditional breakpoints, I used to add code to test for interesting conditions so that I wasn't breaking on every loop iteration or every call of a commonly-used function.

Answer 16

asm volatile ("nop");

Answer 17

In most if not all Javascript debuggers you can use the

debugger;

statement, which behaves as a breakpoint.

Answer 18

I use this in C#:

If (Debugger.IsAttached)
    Debugger.Break();

I throw the IsAttached so that if it doesn't get removed it doesn't effect production code.

Answer 19

Let's consider the desirable properties. The code should

1. be breakpoint-able
2. clearly explain that it's only there for breakpoints.
3. not be immediately visible to a user who runs it.
4. not impact run-time behavior (including running time).

Depending on which optimizer you use, the best breakpoint code may vary.

I'm not much for adding assembly. It's not portable and it screws up the compiler's analysis of the surrounding code. Even if it's a no-op, it might impact performance.

Printing is user-visible. Talking to the debugger feels like you're doing something wrong. I've heard stories about how threading bugs disappeared when the code was ran in the debugger (and that's how debuggers got their name :D). I'd say it's something to avoid, and the problems it solve should be solved by a better debugger instead (an easy-to-use monkey-patcher, maybe?).

I think the best code is bool breakpoint_dummy = /* the value means nothing */ false;. It fits in 80 columns, it explains what it is, and if your optimizing compiler can't deal with unused variables, it'll (hopefully?) compile to xorl eax, eax, a fast and small piece of code (I'd guess). In general, zeros are cheaper than ones ;-)

Answer 20

In C/C++ you can use a no-op:

;

Answer 21

What I've always done is make some kind of #define, e.g. (VC++):

#define NOP __asm{nop}

This can then easily be something else for different platforms, e.g. (gcc):

#define NOP asm("nop")

If there's no inline assembly language, you can fudge in something sensible:

/* insert directives to prevent inlining and optimization */
void nop() {} 

#define NOP (nop())

It can also be turned into nothing for the builds you don't want it in:

#define NOP ((void)0)

This sort of thing can go wherever the platform-specific typedefs and so on go.