What you&#39;re looking for is `-M intel`. Use it as follows.

    objdump -M intel -d program_name

If you want Intel mnemonic codes as well (instead of AT&amp;T mnemonic codes), you can use:

`objdump -M intel intel-mnemonic -D &lt;program&#39;s-object-file&gt;`

What are the differences between `Dispatcher.CurrentDispatcher` (in `System.Windows.Threading`) and `Application.Current.Dispatcher` (in `System.Windows`)?

My gut tells me that `Application.Current.Dispatcher` will never change and is global to all threads in the current application, while `Dispatcher.CurrentDispatcher` may create a new instance of `Dispatcher` depending on the thread from which it was called.

Is that correct?

If it is, is the purpose of `Dispatcher.CurrentDispatcher` primarily for multi-threaded UI?

Dispatcher.CurrentDispatcher vs. Application.Current.Dispatcher

How would I get the key name for the follow? E.g I want &quot;button1&quot; and &quot;button2&quot;?


    var buttons = {
        button1: {
            text: &#39;Close&#39;,
            onclick: function(){
               
            }
        },
        button2: {
            text: &#39;Close2&#39;,
            onclick: function(){
               
            }
        }
    }
     
    var i;
    for(i in buttons){
        if(buttons.hasOwnProperty(i)){
            alert(buttons[i].text);
        }
    } 

I tried using `.push()` although this didn&#39;t work. 

Javascript get object key name

How can I tell `objdump` to emit assembly in Intel Syntax rather than the default AT&amp;T syntax?

How can objdump emit intel syntax

<p>How can I tell <code>objdump</code> to emit assembly in Intel Syntax rather than the default AT&#x26;T syntax?</p>


I know it is possible to have vim open a file at particular line number using this syntax:

    vim +500 filename

However, I would like it to open with the specified line at the top of the editor window, not in the middle.

How can I open vim with a particular line number at the top?

I run a program with LD_PRELOADing a specific library. Like this.

    LD_PRELOAD=./my.so ./my_program

How do I run this program with `gdb`?

How to use gdb with LD_PRELOAD

Is Ghostscript the best option if you want to optimize a PDF file and reduce the file size?

I need to store alot of PDF files and therefore I need to optimize and reduce the file size as much as possible

Does anyone have any experience with Ghostscript and/or other?

# command line

    exec(&#39;gs -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -dCompatibilityLevel=1.4
    -dPDFSETTINGS=/screen -sOutputFile=&#39;.$file_new.&#39; &#39;.$file);

Optimize PDF files (with Ghostscript or other)

I am trying to delete first two lines and last four lines from my text files. How can I do this with Bash?

How to delete first two lines and last four lines from a text file with bash?

In a crontab file, should commands be specified with a trailing &quot;&amp;&quot;, or will the command run in the background anyway?

I have:

    */20 * * * * /home/me/monitor/check.sh /home/me/monitor/check.properties  &gt;&gt; /home/me/monitor/check.log 2&gt;&amp;1 &amp;

I&#39;ve seen contradictory answers to this question in various places. Some say no need to put an &quot;&amp;&quot;, others that without the ampersand cron waits for output from the command, even though all output is redirected.

Should linux cron jobs be specified with an &quot;&amp;&quot; to indicate to run in background?

So I know what the following registers and their uses are supposed to be:

- CS = Code Segment (used for IP)

- DS = Data Segment (used for MOV)

- ES = Destination Segment (used for MOVS, etc.)

- SS = Stack Segment (used for SP)

But what are the following registers intended to be used for?

- FS = &quot;File Segment&quot;?

- GS = ???

Note: I&#39;m **not** asking about any particular operating system -- I&#39;m asking about what they were intended to be used for by the CPU, if anything.

What is the &quot;FS&quot;/&quot;GS&quot; register intended for?

I&#39;ve found that != and == are not the fastest ways for testing for zero or non-zero.

    bool nonZero1 = integer != 0;
    xor eax, eax
    test ecx, ecx
    setne al

    bool nonZero2 = integer &lt; 0 || integer &gt; 0;
    test ecx, ecx
    setne al

    bool zero1 = integer == 0;
    xor	eax, eax
    test ecx, ecx
    sete al

    bool zero2 = !(integer &lt; 0 || integer &gt; 0);
    test ecx, ecx
    sete al

Compiler: VC++ 11
Optimization flags: /O2 /GL /LTCG

This is the assembly output for x86-32. The second versions of both comparisons were ~12% faster on both x86-32 and x86-64. However, on x86-64 the instructions were identical (first versions looked exactly like the second versions), but the second versions were still faster.

1. Why doesn&#39;t the compiler generate the faster version on x86-32?
2. Why are the second versions still faster on x86-64 when the assembly output is identical?

**EDIT: I&#39;ve added benchmarking code. ZERO: 1544ms, 1358ms NON_ZERO: 1544ms, 1358ms**
http://pastebin.com/m7ZSUrcP
or
http://anonymouse.org/cgi-bin/anon-www.cgi/http://pastebin.com/m7ZSUrcP

Note: It&#39;s probably inconvenient to locate these functions when compiled in a single source file, because main.asm goes quite big. I had zero1, zero2, nonZero1, nonZero2 in a separate source file.

**EDIT2: Could someone with both VC++11 and VC++2010 installed run the benchmarking code and post the timings? It might indeed be a bug in VC++11.**

int operators != and == when comparing to zero

As [this question](https://stackoverflow.com/questions/199966/how-do-you-use-gcc-to-generate-assembly-code-in-intel-syntax) shows, with g++, I can do `g++ -S -masm=intel test.cpp`.
Also, with clang, I can do `clang++ -S test.cpp`, but `-masm=intel` is not supported by clang (`warning argument unused during compilation: -masm=intel`). How do I get intel syntax with clang?

How to generate assembly code with clang in Intel syntax?

The `compare` function is a function that takes two arguments `a` and `b` and returns an integer describing their order. If `a` is smaller than `b`, the result is some negative integer. If `a` is bigger than `b`, the result is some positive integer. Otherwise, `a` and `b` are equal, and the result is zero.

This function is often used to parameterize sorting and searching algorithms from standard libraries.

Implementing the `compare` function for characters is quite easy; you simply subtract the arguments:

	int compare_char(char a, char b)
	{
		return a - b;
	}

This works because the difference between two characters is generally assumed to fit into an integer. (Note that this assumption does not hold for systems where `sizeof(char) == sizeof(int)`.)

This trick cannot work to compare integers, because the difference between two integers generally does not fit into an integer. For example, `INT_MAX - (-1) = INT_MIN` suggests that `INT_MAX` is smaller than `-1` (technically, the overflow leads to undefined behavior, but let&#39;s assume modulo arithmetic).

So how can we implement the compare function efficiently for integers? Here is my first attempt:

	int compare_int(int a, int b)
	{
		int temp;
		int result;
		__asm__ __volatile__ (
			&quot;cmp %3, %2 \n\t&quot;
			&quot;mov $0, %1 \n\t&quot;

			&quot;mov $1, %0 \n\t&quot;
			&quot;cmovg %0, %1 \n\t&quot;

			&quot;mov $-1, %0 \n\t&quot;
			&quot;cmovl %0, %1 \n\t&quot;
		: &quot;=r&quot;(temp), &quot;=r&quot;(result)
		: &quot;r&quot;(a), &quot;r&quot;(b)
		: &quot;cc&quot;);
		return result;
	}

Can it be done in less than 6 instructions? Is there a less straightforward way that is more efficient?

Efficient integer compare function

In the [x86-64 Tour of Intel Manuals](http://x86asm.net/articles/x86-64-tour-of-intel-manuals/), I read

&gt; Perhaps the most surprising fact is that an instruction such as `MOV EAX, EBX` automatically zeroes upper 32 bits of `RAX` register.

The Intel documentation (3.4.1.1 General-Purpose Registers in 64-Bit Mode in manual Basic Architecture) quoted at the same source tells us:

&gt; * 64-bit operands generate a 64-bit result in the destination general-purpose register.
&gt; * 32-bit operands generate a 32-bit result, zero-extended to a 64-bit result in the destination general-purpose register.
&gt; * 8-bit and 16-bit operands generate an 8-bit or 16-bit result. The upper 56 bits or 48 bits (respectively) of the destination general-purpose register are not be modified by the operation. If the result of an 8-bit or 16-bit operation is intended for 64-bit address calculation, explicitly sign-extend the register to the full 64-bits.

In x86-32 and x86-64 assembly, 16 bit instructions such as

    mov ax, bx

don&#39;t show this kind of &quot;strange&quot; behaviour that the upper word of eax is zeroed.

Thus: what is the reason why this behaviour was introduced? At a first glance it seems illogical (but the reason might be that I am used to the quirks of x86-32 assembly).

Why do x86-64 instructions on 32-bit registers zero the upper part of the full 64-bit register?

How can you list all functions in a program with GDB?


Ask GDB to list all functions in a program

Does the typical `malloc` (for x86-64 platform and Linux OS) naively lock a mutex at the beginning and release it when done, or does it lock a mutex in a more clever way at a finer level, so that lock contention is reduced? If it indeed does it the second way, how does it do it?

How does malloc work in a multithreaded environment?

I was on Microsoft&#39;s website and noticed two different installers, one for x64 and one for IA-64. Reference:[Installing the .NET Framework 4.5, 4.5.1](http://msdn.microsoft.com/en-us/library/5a4x27ek.aspx)

My understanding is that IA-64 is a subclass of x64, so I&#39;m curious why it would have a separate installer.


What is the difference between x64 and IA-64?

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

Content Type	Original Author	Original Content on Stackoverflow
Question	pythonic	View Question on Stackoverflow
Solution 1 - Linux	Daniel Kamil Kozar	View Answer on Stackoverflow
Solution 2 - Linux	shigoel	View Answer on Stackoverflow

How can objdump emit intel syntax

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

Solution 2 - Linux

Javascript get object key name

Dispatcher.CurrentDispatcher vs. Application.Current.Dispatcher

Attributions