inline-assembly

Say, I want to call a function with the following signature in inline assembly of gcc. How can I do that? int some_function( void * arg ); Generally you'll want to do something like void *x; asm(".. code that writes to register %0" : "=r"(x) : ... int r = some_function(x); asm(".. code that uses the result..." : ... : "r"(r), ... That is, you don't want to do the function call in the inline asm at all. That way you don't have to worry about details of the calling conventions, or stack frame management. 来源： https://stackoverflow.com/questions/7984209/calling-a-function-in-gcc-inline-assembly

When I'm reading the xv6 source code, I'm confused about the syntax of the declaration below. Can anyone explain it to me? extern struct cpu *cpu asm("%gs:0"); David Wohlferd I assume you understand what extern struct cpu *cpu means. The question you have is: What does the asm("%gs:0") part mean? This code is using a gcc extension called asm labels to say that the variable cpu is defined by the assembler string %gs:0 . This is NOT how this extension is intended to be used and is considered a hack . There's an excellent discussion of gs (and fs) here , but in short gs points to the current

I always thought it was but many IDEs and syntax highlighting tools do not highlight ASM in C, but they always do with C++. Is inline assembly part of the C standard (ANSII or ISO) or not? It's not in the ISO C standard (n1570 draft of C2011) as such, but mentioned in annex J (common extensions): J.5.10 The asm keyword 1 The asm keyword may be used to insert assembly language directly into the translator output (6.8). The most common implementation is via a statement of the form: asm ( character-string-literal ); Annex J is informative, not normative, so an implementation need not provide

I remember back in the day with the old borland DOS compiler you could do something like this: asm { mov ax,ex etc etc... } Is there a semi-platform independent way to do this now? I have a need to make a BIOS call, so if there was a way to do this without asm code, that would be equally useful to me. Using GCC __asm__("movl %edx, %eax\n\t" "addl $2, %eax\n\t"); Using VC++ __asm { mov eax, edx add eax, 2 } In GCC, there's more to it than that. In the instruction, you have to tell the compiler what changed, so that its optimizer doesn't screw up. I'm no expert, but sometimes it looks something

So as you know in C and C++ if using Visual-C you can have in line assembly instructions such as: int main() { printf("Hello\n"); __asm int 3 printf("this will not be printed.\n"); return 0; } Which will make a breakpoint inside of the executable. So my question is, is there somekind of function I can use to call __asm using a variable such as a char array. I was thinking something like this: char instruction[100] = "int 3"; __asm instruction But that doesn't seem to really work since it gives 'Invalid OP code'. So can you help with this or it isn't possible at all. Neither C nor C++ are

The idea is that I'd like to collect returned values of double into a vector register for processing for machine imm width at a time without storing back into memory first. The particular processing is a vfma with other two operands that are all constexpr , so that they can simply be summoned by _mm256_setr_pd or aligned/unaligned memory load from constexpr array . Is there a way to store double in %ymm at particular position directly from value in %rax for collecting purpose? The target machine is Kaby Lake. More efficient of future vector instructions are welcome also. Inline-assembly is

Consider the following code: int bn_div(bn_t *bn1, bn_t *bn2, bn_t *bnr) { uint32 q, m; /* Division Result */ uint32 i; /* Loop Counter */ uint32 j; /* Loop Counter */ /* Check Input */ if (bn1 == NULL) return(EFAULT); if (bn1->dat == NULL) return(EFAULT); if (bn2 == NULL) return(EFAULT); if (bn2->dat == NULL) return(EFAULT); if (bnr == NULL) return(EFAULT); if (bnr->dat == NULL) return(EFAULT); #if defined(__i386__) || defined(__amd64__) __asm__ (".intel_syntax noprefix"); __asm__ ("pushl %eax"); __asm__ ("pushl %edx"); __asm__ ("pushf"); __asm__ ("movl %eax, (bn1->dat[i])"); __asm__ ("xorl

I have inherited a pretty interesting piece of code: inline int round(float a) { int i; __asm { fld a fistp i } return i; } My first impulse was to discard it and replace calls with (int)std::round (pre-C++11, would use std::lround if it happened today), but after a while I started to wonder if it might have some merit after all... The use case for this function are all values in [-100, 100] , so even int8_t would be wide enough to hold the result. fistp requires at least a 32 bit memory variable, however, so less than int32_t is just as wasted as more. Now, quite obviously casting the float