`info frame` to show the stack frame info

To read the memory at given addresses you should take a look at `x`

`x/x $esp` for hex `x/d $esp` for signed `x/u $esp` for unsigned etc. x uses the format syntax, you could also take a look at the current instruction via `x/i $eip` etc.

Use:

 - `bt` - backtrace: show stack functions and args
 - `info frame` - show stack start/end/args/locals pointers 
 - `x/100x $sp` - show stack memory

```    
(gdb) bt
#0  zzz () at zzz.c:96
#1  0xf7d39cba in yyy (arg=arg@entry=0x0) at yyy.c:542
#2  0xf7d3a4f6 in yyyinit () at yyy.c:590
#3  0x0804ac0c in gnninit () at gnn.c:374
#4  main (argc=1, argv=0xffffd5e4) at gnn.c:389

(gdb) info frame
Stack level 0, frame at 0xffeac770:
 eip = 0x8049047 in main (goo.c:291); saved eip 0xf7f1fea1
 source language c.
 Arglist at 0xffeac768, args: argc=1, argv=0xffffd5e4
 Locals at 0xffeac768, Previous frame&#39;s sp is 0xffeac770
 Saved registers:
  ebx at 0xffeac75c, ebp at 0xffeac768, esi at 0xffeac760, edi at 0xffeac764, eip at 0xffeac76c

(gdb) x/10x $sp
0xffeac63c:	0xf7d39cba	0xf7d3c0d8	0xf7d3c21b	0x00000001
0xffeac64c:	0xf78d133f	0xffeac6f4	0xf7a14450	0xffeac678
0xffeac65c:	0x00000000	0xf7d3790e
```

You need to use gdb&#39;s memory-display commands. The basic one is [`x`, for examine][1]. There&#39;s an example on the linked-to page that uses

    gdb&gt; x/4xw $sp

to print &quot;four words (`w` ) of memory above the stack pointer (here, `$sp`) in hexadecimal (`x`)&quot;. The quotation is slightly paraphrased.

  [1]: https://web.archive.org/web/20080922034557/http://www.caf.dk/cafonly/gnu/gdb/gdb_56.html

I am trying to learn Automatic Reference Counting in iOS 5. Now the first part of this question should be easy:

 1. Is it correct that I do **NOT** need to write explicit
    release-property statements in my dealloc when using ARC? In other
    words, is it true that the following does **NOT** need a explicit
    dealloc?

        @interface MyClass : NSObject
        @property (strong, nonatomic) NSObject* myProperty;
        @end
    
        @implementation MyClass
        @synthesize myProperty;
        @end

 2.   My next and more important question comes from a line in the [Transitioning to ARC Release Notes][1] document:

    &gt; You do not have to (indeed cannot) release instance variables, but you may need to invoke [self setDelegate:nil] on system classes and other code that isn’t compiled using ARC.

 This begs the question: how do I know which system classes are not compiled with ARC? When should I be creating my own dealloc and explicitly setting strongly retaining properties to nil? Should I assume all NS and UI framework classes used in properties require explicit deallocs?

There is a wealth of information on SO and elsewhere on the practices of releasing a property&#39;s backing ivar when using manual reference tracking, but relatively little about this when using ARC.


  [1]: http://developer.apple.com/library/mac/#releasenotes/ObjectiveC/RN-TransitioningToARC/_index.html

Do I set properties to nil in dealloc when using ARC?

Invoking `:help` in Vim, I got the help manual page with split window. I want to maximize the help manual window and close the other window.

How can I do this? What is the Vim command to do this?

How can I maximize a split window?

I am new to GDB, so I have some questions:

* How can I look at content of the stack?
Example: to see content of register, I type `info registers`. For the stack, what should it be?

* How can I see the content of `$0x4(%esp)`? When I type `print /d $0x4(%esp)`, GDB gives an error.

Platform: Linux and GDB



How can one see content of stack with GDB?

I am new to GDB, so I have some questions:
<ul>
<li>
How can I look at content of the stack?
Example: to see content of register, I type <code>info registers</code>. For the stack, what should it be?
</li>
<li>
How can I see the content of <code>$0x4(%esp)</code>? When I type <code>print /d $0x4(%esp)</code>, GDB gives an error.
</li>
</ul>
Platform: Linux and GDB

While looking through some example C code, I came across this:  

    y -= m &lt; 3;

What does this do? It it some kind of condensed for loop or something? It&#39;s impossible to google for as far as I know.

What does y -= m &lt; 3 mean?

I&#39;m trying to broadcast a message from the root node to all other nodes using MPI_Bcast. However, whenever I run this program it always hangs at the beginning. Does anybody know what&#39;s wrong with it?

    #include &lt;mpi.h&gt;
    #include &lt;stdio.h&gt;
    
    int main(int argc, char** argv) {
            int rank;
            int buf;
            MPI_Status status;
            MPI_Init(&amp;argc, &amp;argv);
            MPI_Comm_rank(MPI_COMM_WORLD, &amp;rank);
    
            if(rank == 0) {
                    buf = 777;
                    MPI_Bcast(&amp;buf, 1, MPI_INT, 0, MPI_COMM_WORLD);
            }
            else {
                    MPI_Recv(&amp;buf, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &amp;status);
                    printf(&quot;rank %d receiving received %d\n&quot;, rank, buf);
            }
    
            MPI_Finalize();
            return 0;
    }


Using MPI_Bcast for MPI communication

This is a situation I encounter frequently as an inexperienced programmer and am wondering about particularly for an ambitious, speed-intensive project of mine I&#39;m trying to optimize.  For the major C-like languages (C, objC, C++, Java, C#, etc) and their usual compilers, will these two functions run just as efficiently?  Is there any difference in the compiled code?

    void foo1(bool flag)
    {
        if (flag)
        {
            //Do stuff
            return;
        }

        //Do different stuff
    }

    void foo2(bool flag)
    {
        if (flag)
        {
            //Do stuff
        }
        else
        {
            //Do different stuff
        }
    }
Basically, is there ever a direct efficiency bonus/penalty when `break`ing or `return`ing early?  How is the stackframe involved?  Are there optimized special cases?  Are there any factors (like inlining or the size of &quot;Do stuff&quot;) that could affect this significantly?

I&#39;m always a proponent of improved legibility over minor optimizations (I see foo1 a lot with parameter validation), but this comes up so frequently that I&#39;d like to set aside all worry once and for all.  

And I&#39;m aware of the pitfalls of premature optimization... ugh, those are some painful memories.

EDIT:  I accepted an answer, but EJP&#39;s answer explains pretty succinctly why the use of a `return` is practically negligible (in assembly, the `return` creates a &#39;branch&#39; to the end of the function, which is extremely fast.  The branch alters the PC register and may also affect the cache and pipeline, which is pretty minuscule.)  For this case in particular, it literally makes no difference because both the `if/else` and the `return` create the same branch to the end of the function.

Efficiency of premature return in a function

I have the following program:

    int main(int argc, char *argv[])
    {
      char ch1, ch2;
      printf(&quot;Input the first character:&quot;); // Line 1
      scanf(&quot;%c&quot;, &amp;ch1); 
      printf(&quot;Input the second character:&quot;); // Line 2
      ch2 = getchar();
      
      printf(&quot;ch1=%c, ASCII code = %d\n&quot;, ch1, ch1);
      printf(&quot;ch2=%c, ASCII code = %d\n&quot;, ch2, ch2);
      
      system(&quot;PAUSE&quot;);	
      return 0;
    }

As the author of the above code have explained:
The program will not work properly because at Line 1, when the user presses Enter, it will leave in the input buffer 2 character: `Enter key (ASCII code 13)` and `\n (ASCII code 10)`. Therefore, at Line 2, it will read the `\n` and will not wait for the user to enter a character.

OK, I got this. But my first question is: Why the second `getchar()` (`ch2 = getchar();`) does not read the `Enter key (13)`, rather than `\n` character?

Next, the author proposed 2 ways to solve such probrems:

1. use `fflush()`

2. write a function like this:

        void
        clear (void)
        {    
          while ( getchar() != &#39;\n&#39; );
        }

This code worked actually. But I cannot explain myself how it works? Because in the while statement, we use `getchar() != &#39;\n&#39;`, that means read any single character except `&#39;\n&#39;`? if so, in the input buffer still remains the `&#39;\n&#39;` character?

How to clear input buffer in C?

I got a code snippet in which there is a

    printf(&quot;%.*s\n&quot;)

what does the `%.*s` mean?

What does &quot;%.*s&quot; mean in printf?

I&#39;ve been working with C for a short while and very recently started to get into ASM. When I compile a program:

    int main(void)
      {
      int a = 0;
      a += 1;
      return 0;
      }


The objdump disassembly has the code, but nops after the ret:

    ...
    08048394 &lt;main&gt;:
     8048394:       55                      push   %ebp
     8048395:       89 e5                   mov    %esp,%ebp
     8048397:       83 ec 10                sub    $0x10,%esp
     804839a:       c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%ebp)
     80483a1:       83 45 fc 01             addl   $0x1,-0x4(%ebp)
     80483a5:       b8 00 00 00 00          mov    $0x0,%eax
     80483aa:       c9                      leave  
     80483ab:       c3                      ret    
     80483ac:       90                      nop
     80483ad:       90                      nop
     80483ae:       90                      nop
     80483af:       90                      nop
    ...

From what I learned nops do nothing, and since after ret wouldn&#39;t even be executed.

My question is: why bother? Couldn&#39;t ELF(linux-x86) work with a .text section(+main) of any size?

I&#39;d appreciate any help, just trying to learn.


Why does GCC pad functions with NOPs?

Is there something like a modulo operator or instruction in x86 assembly?


Assembly Language - How to do Modulo?

I am reading definitions over and over again and I still not getting what are SP and LR in ARM? I understand PC (it shows next instruction&#39;s address), SP and LR probably are similar, but I just don&#39;t get what it is. Could you please help me?

**edit:** if you could explain it with examples, it would be superb.

**edit:** finally figured out what LR is for, still not getting what SP is for.

What are SP (stack) and LR in ARM?

How can the theoretical peak performance of 4 floating point operations (double precision) per cycle be achieved on a modern x86-64 Intel CPU?

As far as I understand it takes three cycles for an [SSE][1] `add` and five cycles for a `mul` to complete on most of the modern Intel CPUs (see for example [Agner Fog&#39;s &#39;Instruction Tables&#39;][2] ). Due to pipelining, one can get a throughput of one `add` per cycle, if the algorithm has at least three independent summations. Since that is true for both packed `addpd` as well as the scalar `addsd` versions and SSE registers can contain two `double`&#39;s, the throughput can be as much as two flops per cycle.

Furthermore, it seems (although I&#39;ve not seen any proper documentation on this) `add`&#39;s and `mul`&#39;s can be executed in parallel giving a theoretical max throughput of four flops per cycle.

However, I&#39;ve not been able to replicate that performance with a simple C/C++ programme. My best attempt resulted in about 2.7 flops/cycle. If anyone can contribute a simple C/C++ or assembler programme which demonstrates peak performance, that&#39;d be greatly appreciated.

My attempt:

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    #include &lt;math.h&gt;
    #include &lt;sys/time.h&gt;

    double stoptime(void) {
       struct timeval t;
       gettimeofday(&amp;t,NULL);
       return (double) t.tv_sec + t.tv_usec/1000000.0;
    }

    double addmul(double add, double mul, int ops){
       // Need to initialise differently otherwise compiler might optimise away
       double sum1=0.1, sum2=-0.1, sum3=0.2, sum4=-0.2, sum5=0.0;
       double mul1=1.0, mul2= 1.1, mul3=1.2, mul4= 1.3, mul5=1.4;
       int loops=ops/10;          // We have 10 floating point operations inside the loop
       double expected = 5.0*add*loops + (sum1+sum2+sum3+sum4+sum5)
                   + pow(mul,loops)*(mul1+mul2+mul3+mul4+mul5);

       for (int i=0; i&lt;loops; i++) {
          mul1*=mul; mul2*=mul; mul3*=mul; mul4*=mul; mul5*=mul;
          sum1+=add; sum2+=add; sum3+=add; sum4+=add; sum5+=add;
       }
       return  sum1+sum2+sum3+sum4+sum5+mul1+mul2+mul3+mul4+mul5 - expected;
    }

    int main(int argc, char** argv) {
       if (argc != 2) {
          printf(&quot;usage: %s &lt;num&gt;\n&quot;, argv[0]);
          printf(&quot;number of operations: &lt;num&gt; millions\n&quot;);
          exit(EXIT_FAILURE);
       }
       int n = atoi(argv[1]) * 1000000;
       if (n&lt;=0)
           n=1000;

       double x = M_PI;
       double y = 1.0 + 1e-8;
       double t = stoptime();
       x = addmul(x, y, n);
       t = stoptime() - t;
       printf(&quot;addmul:\t %.3f s, %.3f Gflops, res=%f\n&quot;, t, (double)n/t/1e9, x);
       return EXIT_SUCCESS;
    }

Compiled with:

    g++ -O2 -march=native addmul.cpp ; ./a.out 1000

produces the following output on an Intel Core i5-750, 2.66&amp;nbsp;GHz:

    addmul:  0.270 s, 3.707 Gflops, res=1.326463

That is, just about 1.4 flops per cycle. Looking at the assembler code with
`g++ -S -O2 -march=native -masm=intel addmul.cpp` the main loop seems kind of
optimal to me.

    .L4:
    inc    eax
    mulsd    xmm8, xmm3
    mulsd    xmm7, xmm3
    mulsd    xmm6, xmm3
    mulsd    xmm5, xmm3
    mulsd    xmm1, xmm3
    addsd    xmm13, xmm2
    addsd    xmm12, xmm2
    addsd    xmm11, xmm2
    addsd    xmm10, xmm2
    addsd    xmm9, xmm2
    cmp    eax, ebx
    jne    .L4

Changing the scalar versions with packed versions (`addpd` and `mulpd`) would double the flop count without changing the execution time and so I&#39;d get just short of 2.8 flops per cycle. Is there a simple example which achieves four flops per cycle?

Nice little programme by Mysticial; here are my results (run just for a few seconds though):

 - `gcc -O2 -march=nocona`: 5.6 Gflops out of 10.66 Gflops (2.1 flops/cycle)
 - `cl /O2`, openmp removed: 10.1 Gflops out of 10.66 Gflops (3.8 flops/cycle)


It all seems a bit complex, but my conclusions so far:

 - `gcc -O2` changes the order of independent floating point operations with
   the aim of alternating
   `addpd` and `mulpd`&#39;s if possible. Same applies to `gcc-4.6.2 -O2 -march=core2`.

 - `gcc -O2 -march=nocona` seems to keep the order of floating point operations as defined in
   the C++ source.

 - `cl /O2`, the 64-bit compiler from the
   [SDK for Windows 7][3]
   does loop-unrolling automatically and seems to try and arrange operations
   so that groups of three `addpd`&#39;s alternate with three `mulpd`&#39;s (well, at least on my system and for my simple programme).

 - My [Core i5 750][4] ([Nehalem architecture][5])
   doesn&#39;t like alternating add&#39;s and mul&#39;s and seems unable
   to run both operations in parallel. However, if grouped in 3&#39;s, it suddenly works like magic.

 - Other architectures (possibly [Sandy Bridge][6] and others) appear to
   be able to execute add/mul in parallel without problems
   if they alternate in the assembly code.

 - Although difficult to admit, but on my system `cl /O2` does a much better job at low-level optimising operations for my system and achieves close to peak performance for the little C++ example above. I measured between
   1.85-2.01 flops/cycle (have used clock() in Windows which is not that precise. I guess, need to use a better timer - thanks Mackie Messer).

 - The best I managed  with `gcc` was to manually loop unroll and arrange
   additions and multiplications in groups of three. With
   `g++ -O2 -march=nocona  addmul_unroll.cpp`
   I get at best `0.207s, 4.825 Gflops` which corresponds to 1.8 flops/cycle
   which I&#39;m quite happy with now.

In the C++ code I&#39;ve replaced the `for` loop with:

       for (int i=0; i&lt;loops/3; i++) {
           mul1*=mul; mul2*=mul; mul3*=mul;
           sum1+=add; sum2+=add; sum3+=add;
           mul4*=mul; mul5*=mul; mul1*=mul;
           sum4+=add; sum5+=add; sum1+=add;

           mul2*=mul; mul3*=mul; mul4*=mul;
           sum2+=add; sum3+=add; sum4+=add;
           mul5*=mul; mul1*=mul; mul2*=mul;
           sum5+=add; sum1+=add; sum2+=add;

           mul3*=mul; mul4*=mul; mul5*=mul;
           sum3+=add; sum4+=add; sum5+=add;
       }

And the assembly now looks like:

    .L4:
    mulsd    xmm8, xmm3
    mulsd    xmm7, xmm3
    mulsd    xmm6, xmm3
    addsd    xmm13, xmm2
    addsd    xmm12, xmm2
    addsd    xmm11, xmm2
    mulsd    xmm5, xmm3
    mulsd    xmm1, xmm3
    mulsd    xmm8, xmm3
    addsd    xmm10, xmm2
    addsd    xmm9, xmm2
    addsd    xmm13, xmm2
    ...

  [1]: https://en.wikipedia.org/wiki/Streaming_SIMD_Extensions
  [2]: http://agner.org/optimize/instruction_tables.pdf
  [3]: http://www.microsoft.com/download/en/details.aspx?id=3138
  [4]: http://en.wikipedia.org/wiki/List_of_Intel_Core_i5_microprocessors#Based_on_Nehalem_microarchitecture
  [5]: http://en.wikipedia.org/wiki/Nehalem_%28microarchitecture%29
  [6]: http://en.wikipedia.org/wiki/Sandy_bridge


How do I achieve the theoretical maximum of 4 FLOPs per cycle?

How can I permanently change the disassembly flavor in GDB.  I tried:`set disassembly-flavor intel` in GDB, but when I fire up GDB later it still has the att flavor.

Permanently Change Disassembly Flavor in GDB

My program operates like this:

    exe -p param1 -i param2 -o param3

It crashed and generated a core dump file, `core.pid`.

I want to analyze the core dump file by

    gdb ./exe -p param1 -i param2 -o param3 core.pid

But GDB recognizes the parameters of the EXE file as GDB&#39;s input.

How do I analyze a core dump file in this situation?


How do I analyze a program&#39;s core dump file with GDB when it has command-line parameters?

When debugging with GDB， i usually using layout src to check my code. But when i open it, i don&#39;t know how to close it. It seems that there are some other layout, and when open a new layout, it will split the window, but i still can not found a command to merge the splitted windows.

How to close layout SRC windows in gdb?

I typically run my program with:

    perl -e &#39;print &quot;A&quot;x200&#39; | ./vuln_prog

The stdin is consumed by a `gets()` function in C++.

If this were just a command argument, I could open gdb by doing:

    gdb ./vuln_prog
    run $(perl -e &#39;print &quot;A&quot;x200&#39;)

However, my scenario is not a command argument, but rather input (STDIN?).  How would I debug this in gdb?  I&#39;ve tried a bunch of options, but nothing seems to really work.

I would normally just run gdb on the process, and when it prompts for user input, type it in, however I&#39;m not wanting to type just &quot;A&quot;.  I want to type all chars from \x00-\xff, which I can&#39;t type.


gdb - debugging with piped input (not arguments)

I&#39;m debugging a C++ program with GDB.

I have a pointer to an object of certain class. The pointer is declared to be of some super class which is extended by several sub-classes.

There is no fields in the object to specify the precise class type of this object but some virtual functions (e.g. bool is_xxx()) are defined to tell the class type at runtime.

Is there some way to tell the precise class type of an object in GDB without calling these virtual functions. Calling such functions in GDB may generate confusing result when the program is multi-threaded.


Content Type	Original Author	Original Content on Stackoverflow
Question	user478571	View Question on Stackoverflow
Solution 1 - C	DipSwitch	View Answer on Stackoverflow
Solution 2 - C	gaoithe	View Answer on Stackoverflow
Solution 3 - C	unwind	View Answer on Stackoverflow

How can one see content of stack with GDB?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Solution 3 - C

How can I maximize a split window?

Do I set properties to nil in dealloc when using ARC?

Attributions