blocks|key|2534118|text|好吧，你没特别说，但是在你的帖子里，你似乎在使用gcc及其带约束的内联asm语法(其他C编译器有非常不同的内联语法)。也就是说，您可能需要使用AT&T汇编语言语法，而不是Intel，因为这就是gcc使用的语法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2534119|如上所述，让我们来看看你的write2函数。首先，您不想创建堆栈帧，因为gcc将创建一个堆栈帧，所以如果您在asm代码中创建一个堆栈帧，您将最终得到两个帧，并且事情可能会变得非常混乱。其次，由于gcc正在布局堆栈帧，因此您不能使用"ebp+%2B+offset“访问var，因为您不知道它是如何布局的。|2534120|这就是约束的用途--您可以说明您希望gcc将值放在什么位置(任何寄存器、内存、特定寄存器)，以及在asm代码中使用"%25X“。最后，如果您在asm代码中使用显式寄存器，则需要在第三部分中列出它们(在输入约束之后)，以便gcc知道您正在使用它们。否则，它可能会将一些重要的值放在其中一个寄存器中，而您将重写该值。|2534121|您还需要告诉编译器，内联asm将或可能读取或写入输入操作数指向的内存；这并不是暗示。|2534122|因此，您的write2函数如下所示：|2534123|void+write2(char+*str,+int+len)+{
++++__asm__+volatile+(
++++++++"movl+$4,+%25%25eax;"++++++//+SYS_write
++++++++"movl+$1,+%25%25ebx;"++++++//+file+descriptor+=+stdout_fd
++++++++"movl+%250,+%25%25ecx;"
++++++++"movl+%251,+%25%25edx;"
++++++++"int+$0x80"
++++++++::+"g"+(str),+"g"+(len)+++++++//+input+values+we+MOV+from
++++++++:+"eax",+"ebx",+"ecx",+"edx",+//+registers+we+destroy
++++++++++"memory"++++++++++++++++++++//+memory+has+to+be+in+sync+so+we+can+read+it
+++++);
}|code-block|syntax|javascript|2534124|注意AT&T语法--+src，dest而不是dest，src和%25放在寄存器名称之前。|offset|length|style|CODE|2534125|现在这将会工作，但它的效率很低，因为它将包含许多额外的mov。通常，您不应该在asm代码中使用mov指令或显式寄存器，因为最好使用约束来说明您想要的东西的位置，并让编译器确保它们在那里。这样，优化器可能会去掉大部分mov，特别是在它内联函数的情况下(如果您指定-O3，它就会这么做)。方便的是，i386机器模型具有针对特定寄存器的约束，因此您可以这样做：|2534126|void+write2(char+*str,+int+len)+{
++++__asm__+volatile+(
++++++++"movl+$4,+%25%25eax;"
++++++++"movl+$1,+%25%25ebx;"
++++++++"int+$0x80"
++++++++::+"c"+(str),+/*+c+constraint+tells+the+compiler+to+put+str+in+ecx+*/
+++++++++++"d"+(len)++/*+d+constraint+tells+the+compiler+to+put+len+in+edx+*/
++++++++:+"eax",+"ebx",+"memory");
}|2534127|甚至更好|2534128|//+UNSAFE:+destroys+EAX+(with+return+value)+without+telling+the+compiler
void+write2(char+*str,+int+len)+{
++++__asm__+volatile+("int+$0x80"
++++++++::+"a"+(4),+"b"+(1),+"c"+(str),+"d"+(len)
++++++++:+"memory");
}|2534129|还要注意volatile的使用，它需要告诉编译器，即使没有使用它的输出(其中没有输出)，也不能将其作为失效来消除。(没有输出操作数的asm已经是隐式的volatile，但是当真正的目的不是计算某些东西时，显式地设置它并没有什么坏处；它是为了产生像系统调用这样的副作用。)|2534130|编辑|BOLD|2534131|最后要注意的是，此函数正在执行一个write系统调用，它确实返回eax中的一个值--写入的字节数或错误代码。所以你可以通过一个输出约束来实现：|2534132|int+write2(const+char+*str,+int+len)+{
++++__asm__+volatile+("int+$0x80"+
+++++:+"=a"+(len)
+++++:+"a"+(4),+"b"+(1),+"c"+(str),+"d"+(len),
+++++++"m"(+*(const+char+(*)[])str+)+++++++//+"dummy"+input+instead+of+memory+clobber
+++++);
++++return+len;
}|2534133|所有系统调用都以EAX格式返回。从-4095到-1+(含)的值为负errno代码，其他值为非错误。(这适用于全局的所有Linux系统调用)。|2534134|如果您正在编写一个通用的系统调用包装器，那么您可能需要一个"memory"封装器，因为不同的系统调用具有不同的指针操作数，并且可能是输入或输出。如果省略了https://godbolt.org/z/GOXBue，请参阅this+answer获取有关虚拟内存输入/输出的更多详细信息。|2534135|使用这个输出操作数，您需要显式的volatile+--每次在源代码中“运行”asm语句时，只需要一个write系统调用。否则，允许编译器假定它的存在只是为了计算它的返回值，并且可以消除对相同输入的重复调用，而不是编写多行代码。(或者，如果没有检查返回值，则将其完全删除。)|2534136|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/GOXBue|1|https://stackoverflow.com/questions/34244185/looping-over-arrays-with-inline-assembly^0|0|0|0|0|0|0|V|1|0|0|0|0|0|4|8|1U|3|23|8|0|0|2|0|0|0|H|5|N|2|X|5|0|T|8|25|S|0|31|B|1|0|G|8|12|3|1E|5|0^^$0|@$1|2|3|4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1V|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1W|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1X|8|@$Q|1Y|R|1Z|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|20|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|21|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|22|8|@]|9|@]|A|$]]|$1|10|3|11|5|L|7|23|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|24|8|@$Q|25|R|26|S|T]|$Q|27|R|28|S|T]|$Q|29|R|2A|S|T]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2B|8|@$Q|2C|R|2D|S|16]]|9|@]|A|$]]|$1|17|3|18|5|6|7|2E|8|@]|9|@]|A|$]]|$1|19|3|1A|5|L|7|2F|8|@]|9|@]|A|$M|N]]|$1|1B|3|1C|5|6|7|2G|8|@$Q|2H|R|2I|S|T]|$Q|2J|R|2K|S|T]|$Q|2L|R|2M|S|T]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2N|8|@$Q|2O|R|2P|S|T]]|9|@$Q|2Q|R|2R|1|2S]|$Q|2T|R|2U|1|2V]]|A|$]]|$1|1F|3|1G|5|6|7|2W|8|@$Q|2X|R|2Y|S|T]|$Q|2Z|R|30|S|T]|$Q|31|R|32|S|T]]|9|@]|A|$]]|$1|1H|3|-4|5|6|7|33|8|@]|9|@]|A|$]]]|1I|$1J|$5|1K|1L|1M|A|$1N|1O]]|1P|$5|1K|1L|1M|A|$1N|1Q]]]]

Well, you don't say specifically, but by your post, it appears like you're using gcc and its inline asm with constraints syntax (other C compilers have very different inline syntax). That said, you probably need to use AT&amp;T assembler syntax rather than Intel, as that's what gets used with gcc.

So with the above said, lets look at your write2 function. First, you don't want to create a stack frame, as gcc will create one, so if you create one in the asm code, you'll end up with two frames, and things will probably get very confused. Second, since gcc is laying out the stack frame, you can't access vars with "[ebp + offset]" as you don't know how it's being laid out.

That's what the constraints are for -- you say what kind of place you want gcc to put the value (any register, memory, specific register) and the use "%X" in the asm code. Finally, if you use explicit registers in the asm code, you need to list them in the 3rd section (after the input constraints) so gcc knows you are using them. Otherwise it might put some important value in one of those registers, and you'd clobber that value.

You also need to tell the compiler that inline asm will or might read from or write to memory pointed-to by the input operands; that is not implied.

So with all that, your write2 function looks like:

<pre><code>void write2(char *str, int len) {
 __asm__ volatile (
 "movl $4, %%eax;" // SYS_write
 "movl $1, %%ebx;" // file descriptor = stdout_fd
 "movl %0, %%ecx;"
 "movl %1, %%edx;"
 "int $0x80"
 :: "g" (str), "g" (len) // input values we MOV from
 : "eax", "ebx", "ecx", "edx", // registers we destroy
 "memory" // memory has to be in sync so we can read it
 );
}
</code></pre>

Note the AT&amp;T syntax -- src, dest rather than dest, src and <code>%</code> before the register name.

Now this will work, but its inefficient as it will contain lots of extra movs. In general, you should NEVER use mov instructions or explicit registers in asm code, as you're much better off using constraints to say where you want things and let the compiler ensure that they're there. That way, the optimizer can probably get rid of most of the movs, particularly if it inlines the function (which it will do if you specify -O3). Conveniently, the i386 machine model has constraints for specific registers, so you can instead do:

<pre><code>void write2(char *str, int len) {
 __asm__ volatile (
 "movl $4, %%eax;"
 "movl $1, %%ebx;"
 "int $0x80"
 :: "c" (str), /* c constraint tells the compiler to put str in ecx */
 "d" (len) /* d constraint tells the compiler to put len in edx */
 : "eax", "ebx", "memory");
}
</code></pre>

or even better

<pre><code>// UNSAFE: destroys EAX (with return value) without telling the compiler
void write2(char *str, int len) {
 __asm__ volatile ("int $0x80"
 :: "a" (4), "b" (1), "c" (str), "d" (len)
 : "memory");
}
</code></pre>

Note also the use of <code>volatile</code> which is needed to tell the compiler that this can't be eliminated as dead even though its outputs (of which there are none) are not used. (<code>asm</code> with no output operands is already implicitly <code>volatile</code>, but making it explicit doesn't hurt when the real purpose isn't to calculate something; it's for a side effect like a system call.)

edit

One final note -- this function is doing a write system call, which does return a value in eax -- either the number of bytes written or an error code. So you can get that with an output constraint:

<pre><code>int write2(const char *str, int len) {
 __asm__ volatile ("int $0x80" 
 : "=a" (len)
 : "a" (4), "b" (1), "c" (str), "d" (len),
 "m"( *(const char (*)[])str ) // "dummy" input instead of memory clobber
 );
 return len;
}
</code></pre>

All system calls return in EAX. Values from <code>-4095</code> to <code>-1</code> (inclusive) are negative <code>errno</code> codes, other values are non-errors. (This applies globally to all Linux system calls).

If you're writing a generic system-call wrapper, you probably need a <code>"memory"</code> clobber because different system calls have different pointer operands, and might be inputs or outputs. See <a href="https://godbolt.org/z/GOXBue" rel="nofollow noreferrer">https://godbolt.org/z/GOXBue</a> for an example that breaks if you leave it out, and <a href="https://stackoverflow.com/questions/34244185/looping-over-arrays-with-inline-assembly">this answer</a> for more details about dummy memory inputs/outputs.

With this output operand, you need the explicit <code>volatile</code> -- exactly one <code>write</code> system call per time the <code>asm</code> statement "runs" in the source. Otherwise the compiler is allowed to assume that it exists only to compute its return value, and can eliminate repeated calls with the same input instead of writing multiple lines. (Or remove it entirely if you didn't check the return value.)

I'm trying to use inline assembly...
I read this page <a href="http://www.codeproject.com/KB/cpp/edujini_inline_asm.aspx" rel="nofollow">http://www.codeproject.com/KB/cpp/edujini_inline_asm.aspx</a> but I can't understand the parameters passing to my function.

I'm writing a C write example.. this is my function header:

<pre><code>write2(char *str, int len){
}
</code></pre>

And this is my assembly code:

<pre><code>global write2
write2:
 push ebp
 mov ebp, esp
 mov eax, 4 ;sys_write
 mov ebx, 1 ;stdout
 mov ecx, [ebp+8] ;string pointer
 mov edx, [ebp+12] ;string size
 int 0x80 ;syscall
 leave
 ret
</code></pre>

What do I have to do pass that code to the C function... I'm doing something like this:

<pre><code>write2(char *str, int len){
 asm ( "movl 4, %%eax;"
 "movl 1, %%ebx;"
 "mov %1, %%ecx;"
 //"mov %2, %%edx;"
 "int 0x80;"
 :
 : "a" (str), "b" (len)
 );
}
</code></pre>

That's because I don't have an output variable, so how do I handle that?
Also, with this code:

<pre><code>global main
main:
 mov ebx, 5866 ;PID
 mov ecx, 9 ;SIGKILL
 mov eax, 37 ;sys_kill
 int 0x80 ;interruption
 ret 
</code></pre>

How can I put that code inline in my code.. so I can ask for the pid to the user.. like this..
This is my precode

<pre><code>void killp(int pid){
 asm ( "mov %1, %%ebx;"
 "mov 9, %%ecx;"
 "mov 37, %%eax;"
 :
 : "a" (pid) /* optional */
 );
}
</code></pre>

Writing a Linux int 80h system-call wrapper in GNU C inline assembly

我正在尝试使用内联汇编...我读了这个页面，但是我不能理解传递给我的函数的参数。我正在写一个C写的例子..这是我的函数头：write2(char *str, int len){}这是我的汇编代码：global write2write2:    push ebp    mov ebp, esp    mov eax, 4...

问用GNU C内联汇编编写Linux Int80h系统调用包装器
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用GNU C内联汇编编写Linux Int80h系统调用包装器EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用GNU C内联汇编编写Linux Int80h系统调用包装器
EN