As [noted below by @thakis](https://stackoverflow.com/a/23630416/1172350), newer versions of Clang (3.5+) accept the `-masm=intel` argument.

-------

For older versions, this should get clang to emit assembly code with Intel syntax:

    clang++ -S -mllvm --x86-asm-syntax=intel test.cpp

You can use `-mllvm &lt;arg&gt;` to pass in llvm options from the clang command line. Sadly this option doesn&#39;t appear to be well documented, and thus I only found it by browsing through the llvm mailing lists.

As of clang [r208683](http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20140512/105330.html) (clang 3.5+), it understands `-masm=intel`. So if your clang is new enough, you can just use that.

Presuming you can have Clang emit normal LLVM byte codes, you can then use [llc][1] to compile to assembly language, and use its `--x86-asm-syntax=intel` option to get the result in Intel syntax.


  [1]: http://llvm.org/docs/CommandGuide/llc.html

I&#39;ve got a table with several columns making up the primary key. The nature of the data stored allows some of these fields to have ``NULL`` values. I have designed my table as such:

    CREATE TABLE `test` (
    	`Field1` SMALLINT(5) UNSIGNED NOT NULL,
    	`Field2` DECIMAL(5,2) UNSIGNED NULL DEFAULT NULL,
    	PRIMARY KEY (`Field1`, `Field2`)
    )
    COLLATE=&#39;latin1_swedish_ci&#39;
    ENGINE=InnoDB;

However, when I run ``describe test`` it shows like this:

    || *Field* || *Type*                || *Null* || *Key* || *Default* || *Extra* 
    || Field1  || smallint(5) unsigned  || NO     || PRI   ||           ||         
    || Field2  || decimal(5,2) unsigned || NO     || PRI   || 0.00      ||         

And I keep getting an error when inserting a ``NULL`` value.

&gt; Column &#39;Field2&#39; cannot be null

Is this because a field that is part of a primary key cannot be null? What are my alternatives besides using, say, &#39;0&#39; for ``NULL``?


NULL value in multi-column primary key

As title says, I’ve got 500 Internal Server Error from GET request to an IQueryable action. The body of the error is empty. That error happens after my action returns result.

I use ASP.NET Web API RC.

How can I get stack trace of that error?

ASP.NET Web API: Non-descriptive 500 Internal Server Error

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?

<p>As <a href="https://stackoverflow.com/questions/199966/how-do-you-use-gcc-to-generate-assembly-code-in-intel-syntax" target="_blank" rel="noopener noreferrer">this question</a> shows, with g++, I can do <code>g++ -S -masm=intel test.cpp</code>.
Also, with clang, I can do <code>clang++ -S test.cpp</code>, but <code>-masm=intel</code> is not supported by clang (<code>warning argument unused during compilation: -masm=intel</code>). How do I get intel syntax with clang?</p>


I know this is achievable with boost as per:

https://stackoverflow.com/questions/5195990/using-boostaccumulators-how-can-i-reset-a-rolling-window-size-does-it-keep-e

But I really would like to avoid using boost. I have googled and not found any suitable or readable examples.

Basically I want to track the moving average of an ongoing stream of a stream of floating point numbers using the most recent 1000 numbers as a data sample.

What is the easiest way to achieve this?


----------


I experimented with using a circular array, exponential moving average and a more simple moving average and found that the results from the circular array suited my needs best.


Calculate rolling / moving average in C++

&gt; **Possible Duplicate:**  
&gt; [Start thread with member function](https://stackoverflow.com/questions/10673585/start-thread-with-member-function)  

&lt;!-- End of automatically inserted text --&gt;

I have a small class:

    class Test
    {
    public:
      void runMultiThread();
    private:
      int calculate(int from, int to);
    }  

How its possible to run method `calculate` with two differents set of parametrs(for example `calculate(0,10)`, `calculate(11,20)`) in two threads from method `runMultiThread()`?

PS Thanks I have forgotten that I need pass `this`, as parameter.



std::thread calling method of class

As it was the case in Boost, C++11 provides some functions for casting `shared_ptr`:

    std::static_pointer_cast
    std::dynamic_pointer_cast
    std::const_pointer_cast

I am wondering, however, why there are no equivalents functions for `unique_ptr`.

Consider the following simple example:

    class A { virtual ~A(); ... }
    class B : public A { ... }
        
    unique_ptr&lt;A&gt; pA(new B(...));

    unique_ptr&lt;A&gt; qA = std::move(pA); // This is legal since there is no casting
    unique_ptr&lt;B&gt; pB = std::move(pA); // This is not legal

    // I would like to do something like:
    // (Of course, it is not valid, but that would be the idea)
    unique_ptr&lt;B&gt; pB = std::move(std::dynamic_pointer_cast&lt;B&gt;(pA));

Is there any reason why this usage pattern is discouraged, and thus, equivalent functions to the ones present in `shared_ptr` are not provided for `unique_ptr`?

Dynamic casting for unique_ptr

I&#39;m fairly familiar with C++11&#39;s `std::thread`, `std::async` and `std::future` components (e.g. see [this answer](https://stackoverflow.com/a/10998831/596781)), which are straight-forward.

However, I cannot quite grasp what `std::promise` is, what it does and in which situations it is best used. The standard document itself doesn&#39;t contain a whole lot of information beyond its class synopsis, and neither does [std::thread](http://www.stdthread.co.uk/doc/headers/future/promise.html).

Could someone please give a brief, succinct example of a situation where an `std::promise` is needed and where it is the most idiomatic solution?

What is std::promise?

C++ is a static, compiled language, templates are resolved during compile time and so on...

But is it possible to create a function during runtime, that is not described in the source code and has not been converted to machine language during compilation, so that a user can throw at it data that has not been anticipated in the source?

I am aware this cannot happen in a straightforward way, but surely it must be possible, there are plenty of programing languages that are not compiled and create that sort of stuff dynamically that are implemented in either C or C++.

Maybe if factories for all primitive types are created, along with suitable data structures to organize them into more complex objects such as user types and functions, this is achievable?

Any info on the subject as well as pointers to online materials are welcome. Thanks!

EDIT: I am aware it is possible, it is more like I am interested in implementation details :)

Is it possible to create a function dynamically, during runtime in C++?

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?

Is `if (a &lt; 901)` faster than `if (a &lt;= 900)`?

Not exactly as in this simple example, but there are slight performance changes on loop complex code. I suppose this has to do something with generated machine code in case it&#39;s even true.

Is &lt; faster than &lt;=?

Assume we&#39;re trying to use the tsc for performance monitoring and we we want to prevent instruction reordering.

These are our options: 

**1:** `rdtscp` is a serializing call. It prevents reordering around the call to rdtscp.

    __asm__ __volatile__(&quot;rdtscp; &quot;         // serializing read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc variable
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

However, `rdtscp` is only available on newer CPUs. So in this case we have to use `rdtsc`. But `rdtsc` is non-serializing, so using it alone will not prevent the CPU from reordering it.

So we can use either of these two options to prevent reordering:

**2:** This is a call to `cpuid` and then `rdtsc`. `cpuid` is a serializing call.

    volatile int dont_remove __attribute__((unused)); // volatile to stop optimizing
    unsigned tmp;
    __cpuid(0, tmp, tmp, tmp, tmp);                   // cpuid is a serialising call
    dont_remove = tmp;                                // prevent optimizing out cpuid

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

**3:** This is a call to `rdtsc` with `memory` in the clobber list, which prevents reordering

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;, &quot;memory&quot;); // rcx and rdx are clobbered
                                                      // memory to prevent reordering

My understanding for the 3rd option is as follows:

Making the call `__volatile__` prevents the optimizer from removing the asm or moving it across any instructions that could need the results (or change the inputs) of the asm. However it could still move it with respect to unrelated operations. So `__volatile__` is not enough.

Tell the compiler memory is being clobbered: ` : &quot;memory&quot;)`. The `&quot;memory&quot;` clobber means that GCC cannot make any assumptions about memory contents remaining the same across the asm, and thus will not reorder around it.

So my questions are:

 - 1: Is my understanding of `__volatile__` and `&quot;memory&quot;` correct?
 - 2: Do the second two calls do the same thing?
 - 3: Using `&quot;memory&quot;` looks much simpler than using another serializing instruction. Why would anyone use the 3rd option over the 2nd option?

Difference between rdtscp, rdtsc : memory and cpuid / rdtsc?

I study the Linux kernel and found out that for x86_64 architecture the interrupt `int 0x80` doesn&#39;t work for calling system calls&lt;sup&gt;1&lt;/sup&gt;.

**For the i386 architecture (32-bit x86 user-space), what is more preferable: `syscall` or `int 0x80` and why?**

I use Linux kernel version 3.4.

---

Footnote 1: `int 0x80` does work in some cases in 64-bit code, but is never recommended.  https://stackoverflow.com/questions/46087730/what-happens-if-you-use-the-32-bit-int-0x80-linux-abi-in-64-bit-code



What is better &quot;int 0x80&quot; or &quot;syscall&quot; in 32-bit code on Linux?

Which header files provide the intrinsics for the different x86 SIMD instruction set extensions (MMX, SSE, AVX, ...)? It seems impossible to find such a list online. Correct me if I&#39;m wrong.

Header files for x86 SIMD intrinsics

I am trying to create a dumb version of a spin lock. Browsing the web, I came across a assembly instruction called &quot;PAUSE&quot; in x86 which is used to give hint to a processor that a spin-lock is currently running on this CPU. The intel manual and other information available state that 

&gt; The processor uses this hint to avoid the memory order violation in
&gt; most situations, which greatly improves processor performance. For
&gt; this reason, it is recommended that a PAUSE instruction be placed in
&gt; all spin-wait loops. The documentation also mentions that  &quot;wait(some
&gt; delay)&quot; is the pseudo implementation of the instruction.

The last line of the above paragraph is intuitive. If I am unsuccessful in grabbing the lock, I must wait for some time before grabbing the lock again.

However, what do we mean by memory order violation in case of a spin lock? 
Does &quot;memory order violation&quot; mean the incorrect *speculative* load/store of the instructions after spin-lock?

The spin-lock question has been asked on Stack overflow before but the memory order violation question remains unanswered (at-least for my understanding).

 

What is the purpose of the &quot;PAUSE&quot; instruction in x86?

I am working in C++ under Mac OS X (10.8.2) and I recently came up with the need of using C++11 features, which are available through the clang++ compiler using the libc++ stdlib.
However, I also need to use some legacy library compiled and linked against libstdc++ (coming from MacPorts). 

In doing so, I got linking errors, since the headers of the legacy libraries using, e.g., `std::string`, required to be resolved against the `std::__1::basic_string` (i.e., the libc++ implementation of `std::string`) instead of the `std::basic_string` implementation.

Is there a way to mix the two libraries in development (e.g. by using some preprocessors flags?)


Using libstdc++ compiled libraries with clang++ -stdlib=libc++

I&#39;ve got some code in which I need to forward-declare the a template class (or at least, forward-declaring would make things a lot easier for me...). I&#39;ve written a simplified version of the problem I&#39;m having so I can display it here:

    template&lt;bool&gt;
    class MyTemplateClass;
    
    int main( int argc, char* argv[] )
    {
    	MyTemplateClass&lt;false&gt; myTemp;  // error here
    	myTemp.GetTheValue();
    	return 0;
    }
    
    template&lt;bool bShouldMult&gt;
    class MyTemplateClass
    {
    	int m_myint;
    	float m_myfloat;
    
    public:
    	MyTemplateClass() : m_myint(5), m_myfloat(3.0f) {}
    	float GetTheValue()
    	{
    		return m_myint * (bShouldMult ? m_myfloat : 1.0f);
    	}	
    
    };

The error I&#39;m getting at the commented line is:

    Error - implicit instantiation of undefined template &#39;MyTemplateClass&lt;false&gt;&#39;

What other detail do I need to include in a forward declaration of MyTemplateClass? Since the error isn&#39;t coming from the next line down I&#39;m assuming it isn&#39;t due to the fact that the method is undefined. The compiler I&#39;m using is LLVM/CLang, and I&#39;m compiling on Mac.

&quot;Implicit instantiation of undefined template&quot; when forward declaring template class

In my C++11 code I get the clang warning &quot;Declaration requires an exit-time destructor&quot; in the following case:

    static const std::map&lt;int, const someStruct&gt; mymap = {
        {1, {
            &quot;A&quot;,
            &quot;B&quot;,
            &quot;C&quot;
        }},
        {2, {
            &quot;D&quot;,
            &quot;E&quot;,
            &quot;F&quot;
        }}
    };

As far as I understand Google an &quot;exit-time destructor&quot; is required to destroy main() and statics in a deterministic way to prevent crashes on exit due to &quot;already released variables&quot;. Is that right? Can someone explain it better?

Plus: What can I do about it (I don&#39;t want to disable the warning)? The code above is used within context of one thread only.

Looks like this is the way Chromium deals with these cases; would that be the right way for my case as well?

    #define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \
      static type&amp; name = *new type arguments

(Source: https://chromium.googlesource.com/chromium/src/+/32352ad08ee673a4d43e8593ce988b224f6482d3/base/basictypes.h)

How to deal with &quot;exit-time destructor&quot; warning in clang?

Currently I am interested in ARM in general and specifically iphone/android targets. But I just want to know more about clang, since it feels to play important role in the years to come.

I tried

    clang -cc1 --help|grep -i list
    clang -cc1 --help|grep arch|grep -v search
    clang -cc1 --help|grep target

     -triple &lt;value&gt;         Specify target triple (e.g. i686-apple-darwin9)

I know clang has -triplet parameter, but how can I list all possible values for it?
I found that clang is very different to gcc in respect to cross compiling, in GCC world you should have separate binary for everything, like PLATFORM_make or PLATFORM_ld (i*86-pc-cygwin i*86-*-linux-gnu etc. http://git.savannah.gnu.org/cgit/libtool.git/tree/doc/PLATFORMS)

in clang world, it&#39;s only one binary (as I read on some forums). But how do I get the list of supported targets? And if my target it not supported on my distro(linux/windows/macos/whatever) how can I get the one that supports more platform?

if I SVN latest clang like this:

    svn co http://llvm.org/svn/llvm-project/cfe/trunk clang

will I get most of platforms?
It looks like Clang was not built with cross compiling in mind right away, but since it&#39;s llvm based it should be very cross-friendly in theory? thank you!


clang: how to list supported target architectures?

When I try to build my app in `Xcode`, I get this error message:

&gt; PCH file built from a different branch ((clang-425.0.24)) than the
&gt; compiler ((clang-425.0.27))

It doesn&#39;t happen before, but this was the first build after updating Xcode.

Other apps work, but not this specific one.

If I turn off the `&quot;Precompile Prefix Header&quot;` setting, it works.

How do I fix this error and still keep that setting on?

How to fix PCH error?

I tried installing Intel MPI Benchmark on my computer and I got this error:

    fork: retry: Resource temporarily unavailable

Then I received this error again when I ran `ls` and `top` command.

What is causing this error?

Configuration of my machine:

    Dell precision T7500
    Scientific Linux release 6.2 (Carbon)


fork: retry: Resource temporarily unavailable

I&#39;m confused on how many flops per cycle per core can be done with Sandy-Bridge and Haswell.
As I understand it with SSE it should be 4 flops per cycle per core for SSE and 8 flops per cycle per core for AVX/AVX2.  

This seems to be verified here,
https://stackoverflow.com/questions/8389648/how-to-achieve-4-flops-per-cycle
,and here,
https://stackoverflow.com/questions/12027922/sandy-bridge-cpu-specification.

However the link below seems to indicate that Sandy-bridge can do 16 flops per cycle per core and Haswell 32 flops per cycle per core
http://www.extremetech.com/computing/136219-intels-haswell-is-an-unprecedented-threat-to-nvidia-amd.

Can someone explain this to me?

Edit:
I understand now why I was confused.  I thought the term FLOP only referred  to single floating point (SP).  I see now that the test at https://stackoverflow.com/questions/8389648/how-to-achieve-4-flops-per-cycle are actually on double floating point (DP) so they achieve 4 DP FLOPs/cycle for SSE and 8 DP FLOPs/cycle for AVX.  It would be interesting to redo these test on SP.

FLOPS per cycle for sandy-bridge and haswell SSE2/AVX/AVX2

I have an issue with my HAXM installation. Here is the thing. I got this error every single time I tried to install HAXM for my computer:
![Installation error print-screen][1]

Problem is, that my computer supports Virtualization Technology (see pic below). Any idea how to fix this issue?
![enter image description here][2]


  [1]: http://i.stack.imgur.com/IRJU3.png
  [2]: http://i.stack.imgur.com/yW2H5.png

Intel HAXM installation error - This computer does not support Intel Virtualization Technology (VT-x)

I&#39;m trying to use the Intel HAX x86 emulator for Windows (8, if that matters).  I installed everything and created an AVD for the android version, and everything appears correct, but when I run it, I get this output:

    Starting emulator for AVD &#39;x86_QVGA_Level10&#39;
    emulator: device fd:1044
    HAX is working and emulator runs in fast virt mode
    emulator: Failed to sync vcpu reg
    emulator: Failed to sync HAX vcpu context

and the emulator won&#39;t run.  The significant part of this error `(Failed to sync vcpu reg)` is not mentioned ANYWHERE online, except in the [source code for the HAX itself](http://mirror.yongbok.net/pub/linux/android/repository/external/qemu/target-i386/hax-all.c), but I can&#39;t figure out how to make any sense of this.

Can anyone advise about how to get past this error?  I really need to get this working, because debugging on device and in the default emulators is painfully slow.

Content Type	Original Author	Original Content on Stackoverflow
Question	Jesse Good	View Question on Stackoverflow
Solution 1 - C++	dcoles	View Answer on Stackoverflow
Solution 2 - C++	thakis	View Answer on Stackoverflow
Solution 3 - C++	Jerry Coffin	View Answer on Stackoverflow

How to generate assembly code with clang in Intel syntax?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

ASP.NET Web API: Non-descriptive 500 Internal Server Error

NULL value in multi-column primary key

Attributions