How to inline x64 asm in vs2017 ?

[Mahmoudnia]

Hi
Can I use inline x64 asm in vs 2017 ?
When I use inline asm in x64 , this error show up :

nonstandard extension used: '__asm' keyword not supported on this architecture

[deepzero]

There is no x64 inline assembly with the Microsoft compiler.

One of the constraints for the x64 compiler is to have no inline assembler support. This means that functions that cannot be written in C or C++ will either have to be written as subroutines or as intrinsic functions supported by the compiler. Certain functions are performance sensitive while others are not. Performance-sensitive functions should be implemented as intrinsic functions.

[user1]

http://masm32.com/board/index.php?topic=4211.0

maybe useful in check options.

[Archer]

You have several options.
1. Switch to some other compiler like intel or GCC. You can still use Visual Studio, just a different compiler, they don't have inline asm restrictions.
2. Compile a separate .asm and link with other compiled .cpp files. This can be configured, so it's done automatically when the solution is built.
3. Sometimes it's enough to use intrinsics. But of course they don't cover all asm instructions.

[Mahmoudnia]

@Archer
I am trying to use GCC x64

[chants]

Or as a fourth option since it has yet to be mentioned, write a tool which at compile time extracts all inline code from C modules intended for x64 compilation, put them in an .asm file with some type of label or function definition, compile them, replace the C code with an appropriate control flow transfer, and so forth.

Unfortunately, nothing will be exactly equivalent mentioned so far in MSVC as the control flow transfer is pretty hard to avoid.

Best yet might be to keep requesting MS to make the long overdo change as a developer feedback or feature request.

[Evilcry]

Two ways:

- Intrinsics https://msdn.microsoft.com/en-us/library/26td21ds.aspx
- As above suggested, .asm linking here a tutorial on how to setup VS + MASM

http://lallouslab.net/2016/01/11/introduction-to-writing-x64-assembly-in-visual-studio/

Best Regards,
Evilcry

[chants]

But since you are not linking the .asm inline, there are excessive call or jump statements emitted. The best would be if MS were to add it.

[gigaman]

Does one call or jump really matter?
I mean, if you said you couldn't easily access local variables or structures, I'd agree... but "excessive call", it sounds like you are trying to optimize something. In that case inline assembler is hardly any good - it's a blackbox for the compiler (at least for the Microsoft's) so it has to dump the values from registers into local variables and after the inline assembly load them back. In other words, a piece of inline assembly heavily breaks the optimization of the surrounding C code - so it's usually not worth it, it does more damage than one call would (so it's better to write the whole CPU intensive piece of code in assembler as a separate function).

[chants]

It matters because its very convenient to program like this. By having to call/return or jump/jump or what have you (also don't forget all the stack setup and cleanup), it forces calling conventions and requires the parameters to be dealt with and such. Yes the MS implementation is not as clever as in GCC/GAS where you can really customize details of the behavior. I agree for optimization its a lame point as you would better be off with pure asm or optimized C rather than a mix and match without sophisticated inline-ing support.

Further its easier to write portable 64/32 bit code without calling conventions and clever use of macros, as the calling conventions are so different you have to use different assembly instructions (registers vs stack).

A C function can modify itself in memory also using clever tricks with inline assembler which has its obfuscation or other uses.

But I suppose this discussion is easily already documented:

https://msdn.microsoft.com/en-us/library/80ccffx3.aspx

Advantages of Inline Assembly
Because the inline assembler doesn't require separate assembly and link steps, it is more convenient than a separate assembler. Inline assembly code can use any C variable or function name that is in scope, so it is easy to integrate it with your program's C code. Because the assembly code can be mixed inline with C or C++ statements, it can do tasks that are cumbersome or impossible in C or C++.
The uses of inline assembly include:
Writing functions in assembly language.
Spot-optimizing speed-critical sections of code.
Making direct hardware access for device drivers.
Writing prolog and epilog code for "naked" calls.

So optimization is on the list after all

[atom0s]

While you can't use inline asm, you can link ASM files into your program and use a separate compiler such as MASM to build .asm files with your project. Visual Studio has support for this built-in.

If you absolutely need inline asm you can use a different compiler/linker.

[chants]

Well it looks like it will not happen anytime either. Unless we all get together to vote it to the top. Difficult to reason about proving correctness in the compiler I suppose

https://visualstudio.uservoice.com/forums/121579-visual-studio-ide/suggestions/2609085-support-inline-assembler-on-c-64-bit

DECLINED·

Admin
Visual Studio Team (Product Team, Microsoft Visual Studio) responded · May 11, 2016
Because of our experience based implementing x86 inline assembler and the many correctness issues we’ve faced with it, we don’t recommend that developers use this approach and won’t be implementing this for new architectures.
As a workaround, you can use the Microsoft Assembler for x64 (https://msdn.microsoft.com/en-us/library/hb5z4sxd.aspx) to create an .OBJ file that you can link against.
-C++ Team

[Avalon]

Just create a .ASM file, change the build rule to MASM, define the subroutine and call it from the C file.


masm.asm

.CODE

PUBLIC MyAsmRoutine
PUBLIC ChangeRaxRoutine

MyAsmRoutine PROC
push rbp
mov rbp, rsp
call qword ptr [rcx]
mov rsp, rbp
pop rbp
ret
MyAsmRoutine ENDP

ChangeRaxRoutine PROC
mov rax, 0x4141
ChangeRcxRoutine ENDP

END

file.c

void MyAsmRoutine(PVOID pFunc);
void __declspec(naked) ChangeRaxRoutine();

int main()
{
PVOID pNtDirectCall = ....
MyAsmRoutine(pNtDirectCall);
ChangeRaxRoutine();
//now your program will return 0x4141 as RAX is the return code
}

[Insid3Code]

@avalon
Typo...

ChangeRaxRoutine PROC
mov rax, 0x4141
ChangeRcxRoutine ENDP

....
.code

public ChangeRaxRoutine

ChangeRaxRoutine proc
mov rax, 04141h
ChangeRaxRoutine endp
end

[vic4key]

Just an example, hope can help you: https://github.com/vic4key/MS-Mix-Cpp-n-Asm-in-64-bit