Another way:

`break *main+4`

This will add a breakpoint at `0x000000000040044c`  
I think this is easier than writing the whole address!

    Process process = Runtime.getRuntime().exec(&quot;tasklist&quot;);
    BufferedReader reader = 
        new BufferedReader(new InputStreamReader(process.getInputStream()));
    process.waitFor();

process.waitFor() never returns

How can I call a method dynamically when its name is contained in a string variable? For example:

    class MyClass
      def foo; end
      def bar; end
    end

    obj = MyClass.new
    str = get_data_from_user  # e.g. `gets`, `params`, DB access, etc.
    str  #=&gt; &quot;foo&quot;
    # somehow call `foo` on `obj` using the value in `str`.

How can I do this? Is doing so a security risk?

How to call methods dynamically based on their name?

    0x0000000000400448 &lt;main+0&gt;:	push   %rbp
    0x0000000000400449 &lt;main+1&gt;:	mov    %rsp,%rbp
    0x000000000040044c &lt;main+4&gt;:	mov    $0x6,%eax
    0x0000000000400451 &lt;main+9&gt;:	leaveq 
    0x0000000000400452 &lt;main+10&gt;:	retq   

I tried:

    breaki 0x0000000000400448

but it seems that there not such command.

Does gdb have such a feature?

How to break on assembly instruction at a given address in gdb?

<pre><code class="hljs language-perl">0x0000000000400448 &#x3C;main+0>:	push %rbp
0x0000000000400449 &#x3C;main+1>:	mov %rsp,%rbp
0x000000000040044c &#x3C;main+4>:	mov $0x6,%eax
0x0000000000400451 &#x3C;main+9>:	leaveq 
0x0000000000400452 &#x3C;main+10>:	retq 
</code></pre>
I tried:
<pre><code class="hljs">breaki 0x0000000000400448
</code></pre>
but it seems that there not such command.
Does gdb have such a feature?

    0x00000000004004b6 &lt;main+30&gt;:	callq  0x400398 &lt;printf@plt&gt;


Anyone knows?


**UPDATE**

Why two `disas printf` give me different result?

    (gdb) disas printf
    Dump of assembler code for function printf@plt:
    0x0000000000400398 &lt;printf@plt+0&gt;:	jmpq   *0x2004c2(%rip)        # 0x600860 &lt;_GLOBAL_OFFSET_TABLE_+24&gt;
    0x000000000040039e &lt;printf@plt+6&gt;:	pushq  $0x0
    0x00000000004003a3 &lt;printf@plt+11&gt;:	jmpq   0x400388
    
    (gdb) disas printf
    Dump of assembler code for function printf:
    0x00000037aa44d360 &lt;printf+0&gt;:	sub    $0xd8,%rsp
    0x00000037aa44d367 &lt;printf+7&gt;:	mov    %rdx,0x30(%rsp)
    0x00000037aa44d36c &lt;printf+12&gt;:	movzbl %al,%edx
    0x00000037aa44d36f &lt;printf+15&gt;:	mov    %rsi,0x28(%rsp)
    0x00000037aa44d374 &lt;printf+20&gt;:	lea    0x0(,%rdx,4),%rax
    0x00000037aa44d37c &lt;printf+28&gt;:	lea    0x3f(%rip),%rdx        # 0x37aa44d3c2 &lt;printf+98&gt;

What does @plt mean here?

It&#39;s said that the `leave` instruction is the same as :

    mov esp,ebp
    pop ebp

But what is `mov esp,ebp` here for? It doesn&#39;t seem valid to me...

Why does leave do &quot;mov esp,ebp&quot; in x86 assembly?

How are everyday machines (not so much computers and mobile devices as appliances, digital watches, etc) programmed? What kind of code goes into the programming of a Coca-Cola vending machine? How does my coffee maker accept a pre-programmed time and begin brewing a pot of coffee hours later, when that time arrives?

Do these kinds of machines have operating systems inside of them, or is it something even more basic? Are they written in Assembly, C, or some other language?

And, I would really like to find some resource that lists these operating systems or underlying code systems, possibly even with source code if possible. If anyone knows of such a resource (searching yielded nothing for me), that would be fantastic.

How are everyday machines programmed?

&gt;https://stackoverflow.com/questions/5554725/which-value-is-better-to-use-boolean-true-or-integer-1

The above topic made me do some experiments with `bool` and `int` in `if` condition. So just out of curiosity I wrote this program:

    int f(int i) 
    {
    	if ( i ) return 99;   //if(int)
    	else  return -99;
    }
    int g(bool b)
    {
    	if ( b ) return 99;   //if(bool)
    	else  return -99;
    }
    int main(){}

`g++ intbool.cpp -S` generates asm code for each functions as follows:

 - asm code for `f(int)`

        __Z1fi:
           LFB0:
     	         pushl	%ebp
           LCFI0:
    	          movl	%esp, %ebp
           LCFI1:
    	          cmpl	$0, 8(%ebp)
    	          je	L2
    	          movl	$99, %eax
    	          jmp	L3
           L2:
    	          movl	$-99, %eax
           L3:
    	          leave
           LCFI2:
    	          ret


 - asm code for `g(bool)`

        __Z1gb:
           LFB1:
    	          pushl	%ebp
           LCFI3:
    	          movl	%esp, %ebp
           LCFI4:
    	          subl	$4, %esp
           LCFI5:
    	          movl	8(%ebp), %eax
    	          movb	%al, -4(%ebp)
    	          cmpb	$0, -4(%ebp)
    	          je	L5
    	          movl	$99, %eax
    	          jmp	L6
           L5:
    	          movl	$-99, %eax
           L6:
    	          leave
           LCFI6:
    	          ret


Surprisingly, `g(bool)` generates more `asm` instructions! Does it mean that `if(bool)` is little slower than `if(int)`? I used to think `bool` is especially designed to be used in conditional statement such as `if`, so I was expecting `g(bool)` to generate less asm instructions, thereby making `g(bool)` more efficient and fast. 

EDIT:

I&#39;m not using any optimization flag as of now. But even absence of it, why does it generate more asm for `g(bool)` is a question for which I&#39;m looking for a reasonable answer. I should also tell you that `-O2` optimization flag generates exactly same asm. But that isn&#39;t the question. The question is what I&#39;ve asked.

---



Which is faster : if (bool) or if(int)?

Starting with Pentium Pro (P6 microarchitecture), Intel redesigned it&#39;s microprocessors and used internal RISC core under the old CISC instructions. Since Pentium Pro all CISC instructions are divided into smaller parts (uops) and then executed by the RISC core. 

At the beginning it was clear for me that Intel decided to hide new internal architecture and force programmers to use &quot;CISC shell&quot;. Thanks to this decision Intel could fully redesign microprocessors architecture without breaking compatibility, it&#39;s reasonable.

However I don&#39;t understand one thing, why Intel still keeps an internal RISC instructions set hidden for so many years? Why wouldn&#39;t they let programmers use RISC instructions like the use old x86 CISC instructions set? 

If Intel keeps backward compatibility for so long (we still have virtual 8086 mode next to 64 bit mode), Why don&#39;t they allow us compile programs so they will bypass CISC instructions and use RISC core directly? This will open natural way to slowly abandon x86 instructions set, which is deprecated nowadays (this is the main reason why Intel decided to use RISC core inside, right?).

Looking at new Intel &#39;Core i&#39; series I see, that they only extends CISC instructions set adding AVX, SSE4 and others.

Why does Intel hide internal RISC core in their processors?

I tried `b` but seem not:


    (gdb) p/b 0x0000000000400398
    Size letters are meaningless in &quot;print&quot; command.

Is there such a switch?

How to print in binary mode in gdb?

    (gdb) n
    134	  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
    (gdb) n
    (gdb) p a
    $30 = &lt;value optimized out&gt;
    (gdb) p b
    $31 = &lt;value optimized out&gt;
    (gdb) p c
    $32 = 3735928563


How can gdb optimize out my value??

What does &lt;value optimized out&gt; mean in gdb?

I&#39;ve got a full-heap core dump from a dead process on an x86 Linux machine (kernel 2.6.35-22 if it matters), which I&#39;m attempting to debug in GDB. 

Is there a GDB command I can use that means &quot;show me a list of all the memory address regions allocated by this process?&quot; In other words, can I figure out what all the possible valid memory addresses are that I can examine in this dump?

The reason I ask is that I need to search across the *entire process heap* for a certain binary string, and in order to use the `find` command, I need to have a start and end address. Simply searching from 0x00 to 0xff.. doesn&#39;t work because `find` halts as soon as it encounters an address it can&#39;t access:

&gt; (gdb) find /w 0x10000000, 0xff000000,
&gt; 0x12345678 
&gt; 
&gt; warning: Unable to access target memory at 0x105ef883, halting
&gt; search.

So I need to get a list of all the readable address regions in memory so I can search them one at a time.

(The reason I need to do *that* is I need to find all the structs in memory that point *at* a certain address.)

None of `show mem`, `show proc`, `info mem`, `info proc` seem to do what I need.


GDB: Listing all mapped memory regions for a crashed process

I am running GDB and want to examine one of those unfortunate god objects. It takes many pages (and I have a 24&quot; monitor turned sideways!) to see the whole thing.

For ease of use, I&#39;d like GDB to print the object to a file instead of the screen so that I can open it in vi and move around with ease.

With all of GDB&#39;s versatility, there must be a way to do this, right?


GDB print to file instead of stdout

When running a program on GDB, usually, the arguments for the program are given at the `run` command. Is there a way to run the program using GDB and as well as give arguments within a shell script?

I saw an answer in a related question, mentioning that we can attach GDB to the program after the script starts executing. But then I will have to &#39;wait&#39; the program.

Is there another way to do this?



Content Type	Original Author	Original Content on Stackoverflow
Question	compile-fan	View Question on Stackoverflow
Solution 1 - Assembly	Laurent G	View Answer on Stackoverflow
Solution 2 - Assembly	jyz	View Answer on Stackoverflow

How to break on assembly instruction at a given address in gdb?

Assembly Problem Overview

Assembly Solutions

Solution 1 - Assembly

Solution 2 - Assembly

How to call methods dynamically based on their name?

process.waitFor() never returns

Attributions