You can view the contents of the stack with **`x/10x $sp`**

This will print the top 10 elements of the stack.

For the current stack frame:

   * **info frame** lists general info about the frame (where things start in memory, etc.)
   * **info args** lists arguments to the function
   * **info locals** lists local variables stored in the frame


- `bt` (or `backtrace`) will give you a call stack.

- `frame &lt;args&gt;` will select a frame on the call stack for inspection

- `info frame &lt;args&gt;` will give you information about a specific frame from the stack. When called without arguments it will display the currently selected frame

- `info locals` can give you information about any local variables on the stack.

- just try `bt full`, and you will get all frames and locals
- input `frame x`, to enter the *x* frame

by the way, you should know about *process address space* and what it is composed:
[linux virtual address space][1], this will help you understand how the frame is used.


  [1]: https://gabrieletolomei.files.wordpress.com/2013/10/program_in_memory2.png

In `ArrayBlockingQueue`, all the methods that require the lock copy it to a local `final` variable before calling `lock()`.

    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                insert(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

Is there any reason to copy `this.lock` to a local variable `lock` when the field `this.lock` is `final`?

Additionally, it also uses a local copy of `E[]` before acting on it:

    private E extract() {
        final E[] items = this.items;
        E x = items[takeIndex];
        items[takeIndex] = null;
        takeIndex = inc(takeIndex);
        --count;
        notFull.signal();
        return x;
    }

Is there any reason for copying a final field to a local final variable?

In ArrayBlockingQueue, why copy final member field into local final variable?

I have in the same folder a `.bat` and a `.exe` file.
I couldn&#39;t call the `.exe` file from the `.bat` unless I put the full absolute path to it.
Is there a way to don&#39;t specify the path?

How to execute programs in the same directory as the windows batch file?

Right now I&#39;ve been using GDB to disassemble a binary file and check out different registers and whatnot. Is there an easy command to examine everything on the stack? Can this be limited to everything in a function?

How can I examine the stack frame with GDB?

<p>Right now I've been using GDB to disassemble a binary file and check out different registers and whatnot. Is there an easy command to examine everything on the stack? Can this be limited to everything in a function?</p>


As per subject. 

I have some constants hash defined like so:

    #define CONST 40

I&#39;ve set a breakpoint in my program. How do I print the value of that constant? (I know I can just look at the source code, but I want to be sure of it)



How do I print a #defined constant in GDB?

I have a function that is called some large number of times, and eventually segfaults.

However, I don&#39;t want to set a breakpoint at this function and stop after every time it&#39;s called, because I will be here for years.

I&#39;ve heard that I can set a `counter` in GDB for a breakpoint, and each time the breakpoint is hit, the counter is decremented, and only gets triggered when the `counter` = 0.

Is this accurate, and if so how do I do it? Please give the gdb code for setting such a breakpoint.

How to make a GDB breakpoint only break after the point is reached a given number times?

I&#39;d like to know if my program is accessing NULL pointers or stale memory.

The backtrace looks like this:
&lt;pre&gt;
Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x2b0fa4c8 (LWP 1333)]
0x299a6ad4 in pthread_mutex_lock () from /lib/libpthread.so.0
(gdb) bt
#0  0x299a6ad4 in pthread_mutex_lock () from /lib/libpthread.so.0
#1  0x0058e900 in ?? ()
&lt;/pre&gt;


How can I get GDB to tell me what address caused a segfault?

Using a function like this:

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    #include &lt;sys/wait.h&gt;
    #include &lt;unistd.h&gt;
    
    void print_trace() {
        char pid_buf[30];
        sprintf(pid_buf, &quot;--pid=%d&quot;, getpid());
        char name_buf[512];
        name_buf[readlink(&quot;/proc/self/exe&quot;, name_buf, 511)]=0;
        int child_pid = fork();
        if (!child_pid) {           
            dup2(2,1); // redirect output to stderr
            fprintf(stdout,&quot;stack trace for %s pid=%s\n&quot;,name_buf,pid_buf);
            execlp(&quot;gdb&quot;, &quot;gdb&quot;, &quot;--batch&quot;, &quot;-n&quot;, &quot;-ex&quot;, &quot;thread&quot;, &quot;-ex&quot;, &quot;bt&quot;, name_buf, pid_buf, NULL);
            abort(); /* If gdb failed to start */
        } else {
            waitpid(child_pid,NULL,0);
        }
    }


I see the details of print_trace in the output.

What are other ways to do it?

Best way to invoke gdb from inside program to print its stacktrace?

How can I set up `gdb` so that it saves the command history? When starting a new `gdb` session I&#39;d like to use the arrow up keys to access the commands of the previous sessions. 





How can I make gdb save the command history?

I asked this question to get to know how to increase the runtime call stack size in the JVM. I&#39;ve got an answer to this, and I&#39;ve also got many useful answers and comments relevant to how Java handles the situation where a large runtime stack is needed. I&#39;ve extended my question with the summary of the responses.

Originally I wanted to increase the JVM stack size so programs like runs without a `StackOverflowError`.

    public class TT {
      public static long fact(int n) {
        return n &lt; 2 ? 1 : n * fact(n - 1);
      }
      public static void main(String[] args) {
        System.out.println(fact(1 &lt;&lt; 15));
      }
    }

The corresponding configuration setting is the `java -Xss...` command-line flag with a large enough value. For the program `TT` above, it works like this with OpenJDK&#39;s JVM:

    $ javac TT.java
    $ java -Xss4m TT

One of the answers has also pointed out that the `-X...` flags are implementation dependent. I was using

    java version &quot;1.6.0_18&quot;
    OpenJDK Runtime Environment (IcedTea6 1.8.1) (6b18-1.8.1-0ubuntu1~8.04.3)
    OpenJDK 64-Bit Server VM (build 16.0-b13, mixed mode)

It is also possible to specify a large stack only for one thread (see in one of the answers how). This is recommended over `java -Xss...` to avoid wasting memory for threads that don&#39;t need it.

I was curious how large a stack the program above exactly needs, so I&#39;ve run it `n` increased:

   * -Xss4m can be enough for `fact(1 &lt;&lt; 15)`
   * -Xss5m can be enough for `fact(1 &lt;&lt; 17)`
   * -Xss7m can be enough for `fact(1 &lt;&lt; 18)`
   * -Xss9m can be enough for `fact(1 &lt;&lt; 19)`
   * -Xss18m can be enough for `fact(1 &lt;&lt; 20)`
   * -Xss35m can be enough for `fact(1 &lt;&lt; 21)`
   * -Xss68m can be enough for `fact(1 &lt;&lt; 22)`
   * -Xss129m can be enough for `fact(1 &lt;&lt; 23)`
   * -Xss258m can be enough for `fact(1 &lt;&lt; 24)`
   * -Xss515m can be enough for `fact(1 &lt;&lt; 25)`

From the numbers above it seems that Java is using about 16 bytes per stack frame for the function above, which is reasonable.

The enumeration above contains *can be enough* instead of *is enough*, because the stack requirement is not deterministic: running it multiple times with the same source file and the same `-Xss...` sometimes succeeds and sometimes yields a `StackOverflowError`. E.g. for 1 &lt;&lt; 20, `-Xss18m` was enough in 7 runs out of 10, and `-Xss19m` wasn&#39;t always enough either, but `-Xss20m` was enough (in all 100 runs out of 100). Does garbage collection, the JIT kicking in, or something else cause this nondeterministic behavior?

The stack trace printed at a `StackOverflowError` (and possibly at other exceptions as well) shows only the most recent 1024 elements of the runtime stack. An answer below demonstrates how to count the exact depth reached (which might be a lot larger than 1024).

Many people who responded has pointed out that it is a good and safe coding practice to consider alternative, less stack-hungry implementations of the same algorithm. In general, it is possible to convert to a set of recursive functions to iterative functions (using a e.g. `Stack` object, which gets populated on the heap instead of on the runtime stack). For this particular `fact` function, it is quite easy to convert it. My iterative version would look like:

    public class TTIterative {
      public static long fact(int n) {
        if (n &lt; 2) return 1;
        if (n &gt; 65) return 0;  // Enough powers of 2 in the product to make it (long)0.
        long f = 2;
        for (int i = 3; i &lt;= n; ++i) {
          f *= i;
        }
        return f;
      }
      public static void main(String[] args) {
        System.out.println(fact(1 &lt;&lt; 15));
      }
    }

FYI, as the iterative solution above shows it, the `fact` function cannot compute the exact factorial of numbers above 65 (actually, even above 20), because the Java built-in type `long` would overflow. Refactoring `fact` so it would return a `BigInteger` instead of `long` would yield exact results for large inputs as well.

How to increase the Java stack size?

I need to get a stack trace object in Ruby; not to print it, just to get it to do some recording and dumping for later analysis. Is that possible? How?

How to get a stack trace object in Ruby?

I have an application with several Activities in Android and I want the user to be able to log-out by pressing a menu button. The problem I have is that

A) Android doesn&#39;t let you terminate the application and  
B) even when I send the user to the `LoginActivity` again they can always press *back* and get right back to the previous activity they were in.

I already tried to launch the Activity with the two following flags: 

    Intent intent  = new Intent(this, LoginActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);    	
    startActivity(intent);

I also tried with each one of them by themselves.

I also tried calling `finish()` after `startActivity(intent)` as I read in another StackOverflow
question.

How to clear the Android Stack of activities?

Is it possible to view the activity stack in Android for debugging purposes?

View activity stack in Android


Is there any control how much you can Recursively call something?

From a basic test program I get a recursion depth of just over 18k

which depends on the stacksize....

is there a way to set up a chunk of memory (perhaps a thread) with a massive stack to increase recursion depth?



Content Type	Original Author	Original Content on Stackoverflow
Question	GetOffMyLawn	View Question on Stackoverflow
Solution 1 - Gdb	Flow	View Answer on Stackoverflow
Solution 2 - Gdb	Michael Mrozek	View Answer on Stackoverflow
Solution 3 - Gdb	dlanod	View Answer on Stackoverflow
Solution 4 - Gdb	kdbreboot	View Answer on Stackoverflow

How can I examine the stack frame with GDB?

Gdb Problem Overview

Gdb Solutions

Solution 1 - Gdb

Solution 2 - Gdb

Solution 3 - Gdb

Solution 4 - Gdb

How to execute programs in the same directory as the windows batch file?

In ArrayBlockingQueue, why copy final member field into local final variable?

Attributions