You might want to try 

- [Hopper Disassembler][1], 
- [osxdbg][2], 
- [Machoview][3], 
- [otx][4] (otool GUI) 
- and [Affinic Debugger GUI][5].


  [1]: http://www.hopperapp.com/
  [2]: http://freshmeat.sourceforge.net/projects/osxdbg
  [3]: http://sourceforge.net/projects/machoview/
  [4]: https://github.com/x43x61x69/otx
  [5]: http://www.affinic.com/?page_id=109

I als know of &lt;http://www.hopperapp.com/&gt;, but never used it.
(cannot be compared to Ida(Pro))

    foo=&quot;/sdf/here/jfds&quot;
    bar=&quot;${foo##*/}&quot;

Can anyone explain how the &quot;`${foo##*/}`&quot; expression works? I understand it will return the string after the last forward slash (i.e. jfds). However, I have no idea how it does or what this type of expression is called?

Expression after last specific character

In one of my prof slides on ploymorphism, I see this piece of code with a couple of comments:


    discountVariable =              //will produce
      (DiscountSale)saleVariable;//run-time error
    discountVariable = saleVariable //will produce
                                    //compiler error

As you can see, it says in the first casting statement that it&#39;ll produce *run-time* error and in the other one it says it&#39;ll produce *compiler error*.

What makes these errors? and how they differ from each other?



What is the difference between run-time error and compiler error?

I am using the `otool`, `nm` and `Fraise` text editor to disassemble the `Mach-o` binaries. My workflow at this point is pretty straightforward:

&lt;ol&gt;
1. List the existed symbols.
&lt;/ol&gt;

    nm -g

&lt;ol&gt;
2. Get the disasm code. &lt;br/&gt;
&lt;/ol&gt;

    otool -vt

&lt;ol&gt;
3. Copy and paste this output to a text file.
&lt;/ol&gt;

&lt;ol&gt;
4. Read and comment the codes in the text editor :)
&lt;/ol&gt;

I am looking for the tools that simplify the working with disasm code on `Mac OS X`.

What is your favorite disassembler tool in Mac OS X?

I am using the <code>otool</code>, <code>nm</code> and <code>Fraise</code> text editor to disassemble the <code>Mach-o</code> binaries. My workflow at this point is pretty straightforward:
<ol>
<ol>
<li>
List the existed symbols.
</li></ol>
nm -g

</ol>
<ol>
2. Get the disasm code. 
</ol>
<pre><code class="hljs">otool -vt
</code></pre>
<ol>
3. Copy and paste this output to a text file.
</ol>
<ol>
4. Read and comment the codes in the text editor :)
</ol>
I am looking for the tools that simplify the working with disasm code on <code>Mac OS X</code>.

I&#39;m trying to make my project compatible with Snow Leopard and I am not able to remove the autolayout in the nibs using Interface builder (XCode 4.3 on Lion).

Is it possible to remove the constraints and the autolayout in a nib on XCode?

Remove autolayout (constraints) in Interface Builder

I&#39;m looking for the best way to duplicate the Linux &#39;watch&#39; command on Mac&amp;nbsp;OS&amp;nbsp;X. I&#39;d like to run a command every few seconds to pattern match on the contents of an output file using &#39;tail&#39; and &#39;sed&#39;.

What&#39;s my best option on a Mac, and can it be done without downloading software?






OS X Bash, &#39;watch&#39; command

I&#39;m attempting to [re-install Ruby 1.9.3 with a patch that will allow me to use ruby-debug][1].

When following the instructions and running

    rvm reinstall 1.9.3 --patch debug --force-autoconf

It runs through and after applying the patch spits out:

&gt; rvm requires autoreconf to install the selected ruby interpreter however autoreconf was not found in the PATH.

Unfortunately, googling around for how to install autoreconf on OS&amp;nbsp;X&amp;nbsp;v10.7 (Lion) (or much information about it at all) seems to be a dead end.

  [1]: https://github.com/chuckg/chuckg.github.com/blob/master/ruby/193_and_rdebug.md


Install autoreconf on OS X v10.7 (Lion)?

Can someone explain what do these options in Xcode do?

* Enable Scribble
* Enable Guard Edges
* Enable Guard Malloc

what they are and what they do and how useful can they be for debugging/testing?

thanks.

Xcode - scribble, guard edges and guard malloc

OMG, what I&#39;ve done? 

Couple of days ago, I tried using macport to install something, because I&#39;m using Xcode 4.3 and the command-line tool hadn&#39;t been installed by the time, macport wouldn&#39;t work. So I followed some guide to get command-line tool installed, then I used following command:

    sudo xcode-select -switch /Applications/Xcode.app/

which I think screwed everything except macport: now, in Xcode, even a simple single-view iOS project won&#39;t be compiled, it says &quot;UIKit/UIKit.h not found&quot;.

Does anyone know how to correct this? I don&#39;t want to re-install the gigantic Xcode again, gotta do some iOS project tonight, help!

Xcode stops working after set &quot;xcode-select -switch&quot;

I tried to compare the performance of inline assembly language and C++ code, so I wrote a function that add two arrays of size 2000 for 100000 times. Here&#39;s the code:

    #define TIMES 100000
    void calcuC(int *x,int *y,int length)
    {
        for(int i = 0; i &lt; TIMES; i++)
        {
            for(int j = 0; j &lt; length; j++)
                x[j] += y[j];
        }
    }


    void calcuAsm(int *x,int *y,int lengthOfArray)
    {
        __asm
        {
            mov edi,TIMES
            start:
            mov esi,0
            mov ecx,lengthOfArray
            label:
            mov edx,x
            push edx
            mov eax,DWORD PTR [edx + esi*4]
            mov edx,y
            mov ebx,DWORD PTR [edx + esi*4]
            add eax,ebx
            pop edx
            mov [edx + esi*4],eax
            inc esi
            loop label
            dec edi
            cmp edi,0
            jnz start
        };
    }

Here&#39;s `main()`:

    int main() {
        bool errorOccured = false;
        setbuf(stdout,NULL);
        int *xC,*xAsm,*yC,*yAsm;
        xC = new int[2000];
        xAsm = new int[2000];
        yC = new int[2000];
        yAsm = new int[2000];
        for(int i = 0; i &lt; 2000; i++)
        {
            xC[i] = 0;
            xAsm[i] = 0;
            yC[i] = i;
            yAsm[i] = i;
        }
        time_t start = clock();
        calcuC(xC,yC,2000);

        //    calcuAsm(xAsm,yAsm,2000);
        //    for(int i = 0; i &lt; 2000; i++)
        //    {
        //        if(xC[i] != xAsm[i])
        //        {
        //            cout&lt;&lt;&quot;xC[&quot;&lt;&lt;i&lt;&lt;&quot;]=&quot;&lt;&lt;xC[i]&lt;&lt;&quot; &quot;&lt;&lt;&quot;xAsm[&quot;&lt;&lt;i&lt;&lt;&quot;]=&quot;&lt;&lt;xAsm[i]&lt;&lt;endl;
        //            errorOccured = true;
        //            break;
        //        }
        //    }
        //    if(errorOccured)
        //        cout&lt;&lt;&quot;Error occurs!&quot;&lt;&lt;endl;
        //    else
        //        cout&lt;&lt;&quot;Works fine!&quot;&lt;&lt;endl;

        time_t end = clock();

        //    cout&lt;&lt;&quot;time = &quot;&lt;&lt;(float)(end - start) / CLOCKS_PER_SEC&lt;&lt;&quot;\n&quot;;

        cout&lt;&lt;&quot;time = &quot;&lt;&lt;end - start&lt;&lt;endl;
        return 0;
    }

Then I run the program five times to get the cycles of processor, which could be seen as time. Each time I call one of the function mentioned above only.

And here comes the result.

Function of assembly version:
-----------------

    Debug   Release
    ---------------
    732        668
    733        680
    659        672
    667        675
    684        694
    Average:   677

Function of C++ version:
------------

    Debug     Release
    -----------------
    1068      168
     999      166
    1072      231
    1002      166
    1114      183
    Average:  182

The C++ code in release mode is almost 3.7 times faster than the assembly code. Why?

I guess that the assembly code I wrote is not as effective as those generated by GCC. It&#39;s hard for a common programmer like me to wrote code faster than its opponent generated by a compiler.Does that mean I should not trust the performance of assembly language written by my hands, focus on C++ and forget about assembly language?


Is inline assembly language slower than native C++ code?

I don&#39;t understand the `JG/JNLE/JL/JNGE` instructions, which come after CMP.

for example, If I have:

    CMP al,dl
    jg label1

When `al=101; dl =200`.

On what we ask the `jg`? Is it on `al&gt;dl`? or `al-dl&gt;0`?

Same prolbem on the next code:

    test al,dl
    jg label1

I don&#39;t understand what we compare, and on what we ask the &quot;`jg`&quot;.

In other words, I don&#39;t understand when we would jump to label1, and when we wouldn&#39;t.


Assembly - JG/JNLE/JL/JNGE after CMP

This question continues on my question here (on the advice of Mystical):

https://stackoverflow.com/questions/9992054/c-code-loop-performance

----------------

Continuing on my question, when i use packed instructions instead of scalar instructions the code using intrinsics would look very similar:

    for(int i=0; i&lt;size; i+=16) {
        y1 = _mm_load_ps(output[i]);
        …
        y4 = _mm_load_ps(output[i+12]);

        for(k=0; k&lt;ksize; k++){
            for(l=0; l&lt;ksize; l++){
                w  = _mm_set_ps1(weight[i+k+l]);

                x1 = _mm_load_ps(input[i+k+l]);
                y1 = _mm_add_ps(y1,_mm_mul_ps(w,x1));
                …
                x4 = _mm_load_ps(input[i+k+l+12]);
                y4 = _mm_add_ps(y4,_mm_mul_ps(w,x4));
            }
        }
        _mm_store_ps(&amp;output[i],y1);
        …
        _mm_store_ps(&amp;output[i+12],y4);
        }

The measured performance of this kernel is about 5.6 FP operations per cycle, although i would expect it to be exactly 4x the performance of the scalar version, i.e. 4.1,6=6,4 FP ops per cycle. 

Taking the move of the weight factor into account (thanks for pointing that out), the schedule looks like:

![schedule][1]

It looks like the schedule doesn&#39;t change, although there is an extra instruction after the `movss` operation that moves the scalar weight value to the XMM register and then uses `shufps` to copy this scalar value in the entire vector. It seems like the weight vector is ready to be used for the `mulps` in time taking the switching latency from load to the floating point domain into account, so this shouldn&#39;t incur any extra latency.

The `movaps` (aligned, packed move),`addps` &amp; `mulps` instructions that are used in this kernel (checked with assembly code) have the same latency &amp; throughput as their scalar versions, so this shouldn&#39;t incur any extra latency either.

Does anybody have an idea where this extra cycle per 8 cycles is spent on, assuming the maximum performance this kernel can get is 6.4 FP ops per cycle and it is running at 5.6 FP ops per cycle?


-------

By the way here is what the actual assembly looks like:

    …
    Block x: 
      movapsx  (%rax,%rcx,4), %xmm0
      movapsx  0x10(%rax,%rcx,4), %xmm1
      movapsx  0x20(%rax,%rcx,4), %xmm2
      movapsx  0x30(%rax,%rcx,4), %xmm3
      movssl  (%rdx,%rcx,4), %xmm4
      inc %rcx
      shufps $0x0, %xmm4, %xmm4               {fill weight vector}
      cmp $0x32, %rcx 
      mulps %xmm4, %xmm0 
      mulps %xmm4, %xmm1
      mulps %xmm4, %xmm2 
      mulps %xmm3, %xmm4
      addps %xmm0, %xmm5 
      addps %xmm1, %xmm6 
      addps %xmm2, %xmm7 
      addps %xmm4, %xmm8 
      jl 0x401ad6 &lt;Block x&gt; 
    …




  [1]: http://i.stack.imgur.com/vhKri.png

C code loop performance [continued]

I am a beginner to assembly and I don&#39;t know what all the db, dw, dd, things mean.
I have tried to write this little script that does 1+1, stores it in a variable and then displays the result. Here is my code so far:

    .386
    .model flat, stdcall 
    option casemap :none
    include \masm32\include\windows.inc
    include \masm32\include\kernel32.inc
    include \masm32\include\masm32.inc
    includelib \masm32\lib\kernel32.lib
    includelib \masm32\lib\masm32.lib
    .data
    num db ? ; set variable . Here is where I don&#39;t know what data type to use.
    .code
    start:
    mov eax, 1               ; add 1 to eax register
    mov ebx, 1               ; add 1 to ebx register
    add eax, ebx             ; add registers eax and ebx
    push eax                 ; push eax into the stack
    pop num                  ; pop eax into the variable num (when I tried it, it gave me an error, i think  thats because of the data type)
    invoke StdOut, addr num  ; display num on the console.
    invoke ExitProcess       ; exit
    end start

I need to understand what the db, dw, dd things mean and how they affect variable setting and combining and that sort of thing.

Thanks in advance,
Progrmr 

Which variable size to use (db, dw, dd) with x86 assembly?

While writing an optimized `ftol` function I found some very odd behaviour in `GCC 4.6.1`. Let me show you the code first (for clarity I marked the differences):

fast_trunc_one, C:

    int fast_trunc_one(int i) {
        int mantissa, exponent, sign, r;
    
        mantissa = (i &amp; 0x07fffff) | 0x800000;
        exponent = 150 - ((i &gt;&gt; 23) &amp; 0xff);
        sign = i &amp; 0x80000000;
    
        if (exponent &lt; 0) {
            r = mantissa &lt;&lt; -exponent;                       /* diff */
        } else {
            r = mantissa &gt;&gt; exponent;                        /* diff */
        }
    
        return (r ^ -sign) + sign;                           /* diff */
    }
    
fast_trunc_two, C:

    int fast_trunc_two(int i) {
        int mantissa, exponent, sign, r;
    
        mantissa = (i &amp; 0x07fffff) | 0x800000;
        exponent = 150 - ((i &gt;&gt; 23) &amp; 0xff);
        sign = i &amp; 0x80000000;
    
        if (exponent &lt; 0) {
            r = (mantissa &lt;&lt; -exponent) ^ -sign;             /* diff */
        } else {
            r = (mantissa &gt;&gt; exponent) ^ -sign;              /* diff */
        }
    
        return r + sign;                                     /* diff */
    }

Seems the same right? Well GCC disagrees. After compiling with `gcc -O3 -S -Wall -o test.s test.c` this is the assembly output:

fast_trunc_one, generated:

    _fast_trunc_one:
    LFB0:
    	.cfi_startproc
    	movl	4(%esp), %eax
    	movl	$150, %ecx
    	movl	%eax, %edx
    	andl	$8388607, %edx
    	sarl	$23, %eax
    	orl	$8388608, %edx
    	andl	$255, %eax
    	subl	%eax, %ecx
    	movl	%edx, %eax
    	sarl	%cl, %eax
    	testl	%ecx, %ecx
    	js	L5
    	rep
    	ret
    	.p2align 4,,7
    L5:
    	negl	%ecx
    	movl	%edx, %eax
    	sall	%cl, %eax
    	ret
    	.cfi_endproc

fast_trunc_two, generated:
    
    _fast_trunc_two:
    LFB1:
    	.cfi_startproc
    	pushl	%ebx
    	.cfi_def_cfa_offset 8
    	.cfi_offset 3, -8
    	movl	8(%esp), %eax
    	movl	$150, %ecx
    	movl	%eax, %ebx
    	movl	%eax, %edx
    	sarl	$23, %ebx
    	andl	$8388607, %edx
    	andl	$255, %ebx
    	orl	$8388608, %edx
    	andl	$-2147483648, %eax
    	subl	%ebx, %ecx
    	js	L9
    	sarl	%cl, %edx
    	movl	%eax, %ecx
    	negl	%ecx
    	xorl	%ecx, %edx
    	addl	%edx, %eax
    	popl	%ebx
    	.cfi_remember_state
    	.cfi_def_cfa_offset 4
    	.cfi_restore 3
    	ret
    	.p2align 4,,7
    L9:
    	.cfi_restore_state
    	negl	%ecx
    	sall	%cl, %edx
    	movl	%eax, %ecx
    	negl	%ecx
    	xorl	%ecx, %edx
    	addl	%edx, %eax
    	popl	%ebx
    	.cfi_restore 3
    	.cfi_def_cfa_offset 4
    	ret
    	.cfi_endproc

That&#39;s an __extreme__ difference. This actually shows up on the profile too, `fast_trunc_one` is around 30% faster than `fast_trunc_two`. Now my question: what is causing this?

Why does GCC generate such radically different assembly for nearly the same C code?

Is it possible to decompile an APK package or DEX file on Android platform?
Are there any tools that can decompile an APK file?


How to decompile an APK or DEX file on Android platform?

I&#39;ve got a binary installed on my system, and would like to look at the disassembly of a given function. Preferrably using `objdump`, but other solutions would be acceptable as well.

From [this questions][1] I&#39;ve learned that I might be able to disassemble part of the code if I only know the boundary addresses. From [this answer][2] I&#39;ve learned how to turn my split debug symbols back into a single file.

But even operating on that single file, and even disassembling all the code (i.e. without start or stop address, but plain `-d` parameter to `objdump`), I still don&#39;t see that symbol anywhere. Which makes sense insofar as the function in question is static, so it isn&#39;t exported. Nevertheless, `valgrind` will report the function name, so it has to be stored somewhere. 

Looking at the details of the debug sections, I find that name mentioned in the `.debug_str` section, but I don&#39;t know a tool which can turn this into an address range.


  [1]: https://stackoverflow.com/q/6441721/1468366
  [2]: https://stackoverflow.com/a/17599967/1468366

How to disassemble one single function using objdump?

When trying to run an executable I&#39;ve been sent in Mac OS X, I get the following error

    dyld: Library not loaded: libboost_atomic.dylib
      Referenced from: /Users/&quot;Directory my executable is in&quot;
      Reason: image not found
    Trace/BPT trap:5

I have installed the boost libraries and they are located in `/opt/local/lib`. I think the problem has something to do with the executable only looking in the directory it is in as when I paste the &#39;libboost_atomic.dylib&#39; in there, it doesn&#39;t mind about it anymore. Unfortunately then it complains it can&#39;t find the next boost library.

Is there an easy way to fix this?

Content Type	Original Author	Original Content on Stackoverflow
Question	user663896	View Question on Stackoverflow
Solution 1 - Macos	Peter Murphy	View Answer on Stackoverflow
Solution 2 - Macos	n80fr1n60	View Answer on Stackoverflow

What is your favorite disassembler tool in Mac OS X?

Macos Problem Overview

Macos Solutions

Solution 1 - Macos

Solution 2 - Macos

What is the difference between run-time error and compiler error?

Expression after last specific character

Attributions