inline-assembly

When implementing lock-free data structures and timing code it's often necessary to suppress the compiler's optimisations. Normally people do this using asm volatile with memory in the clobber list, but you sometimes see just asm volatile or just a plain asm clobbering memory. What impact do these different statements have on code generation (particularly in GCC, as it's unlikely to be portable)? Just for reference, these are the interesting variations: asm (""); // presumably this has no effect on code generation asm volatile (""); asm ("" ::: "memory"); asm volatile ("" ::: "memory");

I'm attempting to convert RR0D Rasta Ring 0 Debugger from 32-bit mode to 64-bit mode (long mode) in Linux, using gcc. I'm familiar with x86 32-bit assembly (in MS-DOS environment) but I'm a beginner in x86 64-bit assembly and in Linux assembly programming in general. This project is for production use (I need a working non-source debugger), but I also attempt to learn how to do the 32-bit to 64-bit conversion. If possible, I attempt to find a universal way to do 32-bit to 64-bit conversion that could be done on any 32-bit program using regular expressions (so that it can be automatized). I'm

How is it done? What steps do I need to take and what pitfalls and gotchas are there to consider? Hans Sjunnesson I've gotten this to work, thanks to some inside help over at the Apple Devforums , you should sign up if you're a dedicated IPhone developer. First thing's first, it's __asm__() , not plain asm() . Secondly, by default, XCode generates a compilation target that compiles inline assembly against the ARM Thumb instruction set, so usat wasn't recognized as a proper instruction. To fix this, do "Get Info" on the Target. Scroll down to the section "GCC 4.0 - Code Generation" and uncheck

I remember seeing a way to use extended gcc inline assembly to read a register value and store it into a C variable. I cannot though for the life of me remember how to form the asm statement. ephemient Editor's note: this way of using a local register-asm variable is now documented by GCC as "not supported" . It still usually happens to work on GCC, but breaks with clang. (This wording in the documentation was added after this answer was posted, I think.) The global fixed-register variable version has a large performance cost for 32-bit x86, which only has 7 GP-integer registers (not counting

I am working on a cpp project. The project need to be migrated to 64 bit. It contains some Inline assembly code which cannot compile on x64. This is the Function which contain the assembly code: void ExternalFunctionCall::callFunction(ArgType resultType, void* resultBuffer) { #if defined(_NT_) || defined(__OS2__) // I386 // just copy the args buffer to the stack (it's already layed out correctly) int* begin = m_argsBegin; int* ptr = m_argsEnd; int arr[1000], i=0; while (ptr > begin) { int val = *(--ptr); __asm push val } void* functionAddress = m_functionAddress; // call the function & handle

Disclaimer: Words cannot describe how much I detest AT&T style syntax I have a problem that I hope is caused by register clobbering. If not, I have a much bigger problem. The first version I used was static unsigned long long rdtscp(void) { unsigned int hi, lo; __asm__ __volatile__("rdtscp" : "=a"(lo), "=d"(hi)); return (unsigned long long)lo | ((unsigned long long)hi << 32); } I notice there is no 'clobbering' stuff in this version. Whether or not this is a problem I don't know... I suppose it depends if the compiler inlines the function or not. Using this version causes me problems that aren