I often read here advices to compile using MMX instructions. I though this is done automatically, but seems like I'm missing some info

If MMX instuctions need to be "turned on", where and how do i do it ?

(using WinXP with MinGW and latest allegro)

EDIT:
I found something in my DEV-C++, i turned on the MMX instruction and recognized some performance incerease (from 120fps to 130fps).

But still, what setting is recommended ? SSE or MMX ? What will happen on CPU withouth this instruction?

But that only applyes to allegro itself (and only the asm routines). If you want the compiler to generate MMX/SSE code for your project you have to enable it. The problem is that your program then won't work on CPU's without these instruction sets. MMX is a good option, since any x86 computer less than 7 years ols will have it.

But as noted, using such options will require the target computer to have those instructions available. My 1.1GHz AMD doesn't have SSE. Just MMX and 3DNow (and AFAIK, no Intel chips have 3DNow). IF you want to do it, listen to Oscar. MMX might be a good one to enable as most people have that.

*WARNING* you cant run MMX/SSE code on non-MMX/SSE systems.

and its not easy to warn using a MessageBox() in the app; things like that aren't even guaranteed to work.

It's best to compile two versions of the program - one with mmx and sse enabled and one without them. That way you can make sure that everyone can run the program.

Could always go for three.. w/ MMX, w/ MMX+3DNow, w/ MMX+SSE. Would be a shame if I couldn't use an enhanced version because I only have MMX and 3DNow.

With some clever coding, you could check what to use in real time (check Allegro's cpu_capabilities), and put it all in one EXE.

The files with the functions in question, you'd compile with nothing, then with -mmmx then with -mmmx -m3dnow, etc, with each pass adding _mmx or _mmx_3dnow to the end of the functions. Then do:

if((cpu_capabilities&(CPU_MMX|CPU_SSE)) == (CPU_MMX|CPU_SSE))
   function_mmx_sse();
else if((cpu_capabilities&(CPU_MMX|CPU_3DNOW)) == (CPU_MMX|CPU_3DNOW))
   function_mmx_3dnow();
else if(cpu_capabilities&CPU_MMX)
   function_mmx();
else
   function();

Or, you can use function pointers and set them up. You'll incur some hit from the branching (though it'll be constant, so the CPU should predict it well enough) though, but you can make it so each "optimized" function calls other optimized functions without needed to recheck. eg:
when compiled with -DEXT=_MMX_3DNOW:

void some_other_funcEXT();
void some_funcEXT();
{
  blah_blah;
  some_other_funcEXT();
}

So you'd only need to check when "entering" the optimized functions. How much you want to optimize in this way is up to you.. you can optimize everything excluding main, and have that select the properly optimized function for the main loop. But of course, this'll seriously bloat your code, so you need to determine how much would be beneficial.

I've done this with raw graphic code (no Allegro):

int mmx_available; //equivalent to allegros cpu bits

extern void mmx_blit(void);
extern void genreg_blit(void);

void (blit *)(void);

//during initialization
if(mmx_available)
blit = mmx_blit();
else
blit = genreg_blit();

//in game loop
blit();

Of course this depends on not having huge chunks of code that differ, but the 90/10 rule implies that optimizing the whole thing/outer loops is a waste of time.

[EDIT]
I have an AMD K6-2, and -march=k6-2 usually runs slower than -march=pentium (!)

IIRC, you don't simply "turn on" MMX, you have to use the special instructions (which will cause errors if you don't specify the compiler flag). Maybe in a few years gcc will be able to use them for general purpose stuff like it can use conditional moves now. (Pentium Pro stuff)I haven't used those special instructions in C code myself, but I remember seeing them somewhere in "info gcc". Also, Doesn't M$ QuikView show the functions in a dll?

Actually, yes you do. The compiler will produce asm code that has MMX instructions in it. You can use the special instructions as well if you wish to have more control of how things are done.

yes it is, because you put the check in main.c which you compile with all the cpu flags off, and link with the rest of the program which is compiled with them on.

Fladimir, could you please give me an example? I looked all through gcc info (gcc 3.4.3) and it seemed to imply that MMX and 3DNow were "made available" by -mmmx -m3dnow etc. Grepping the Allegro source for "mm0" through "mm7" only found *.S files, and objdump in the /obj directory only found files that matched the .S files. I also tried running reams of other code through gcc with -march=k6-2 -mmmx -m3dnow -S and didn't get any mm(n). The docs do say that sse - sse2 instructions are used automatically and I could indeed find xmm0 etc after using the right compiler switches, although trying to compile to exe made as bomb out on something called XMMWORD. If you could give me an example it'd really be nice, else I'll have to keep doing it by hand with NASM...

(The builtins do allow you to use mmx and 3dnow, but it's so hairy with all those required unions, typedefs & stuff like __builtin_gcc_pfadd it's worse than asm! And I couldn't find an emms equivalent for mmx without 3dnow so I had to write an asm inline to avoid NAN's trying to print out the results to see if it worked.)