Get argument from command line in inline assembly - c

Question

I have to count the number of words in a string that you get as an argument from the command line.
First I made this program:
#include <stdio.h>
#include <string.h>
int main( int argc, char *argv[] ){
char* s;
if(argc==1)
{
s="";
} else {
s = argv[1];
}
//char* s = " aqr b qabxx xryc pqr"; example
int x;
asm volatile(
".intel_syntax noprefix;"
"mov eax,%1;"
"xor edx,edx;"
"jmp petla;"
"petla0:"
"inc eax;"
"petla:"
"cmp [eax],byte ptr 0;"
"jz wyjscie;"
"cmp [eax],byte ptr 32;"
"jz petla0;"
"inc edx;"
"petla1:"
"inc eax;"
"cmp [eax],byte ptr 0;"
"jz wyjscie;"
"cmp [eax],byte ptr 32;"
"jz petla;"
"jmp petla1;"
"wyjscie:"
"mov %0,edx;"
".att_syntax prefix;"
: "=r" (x)
: "r" (s)
: "eax","edx"
);
printf("%hd\n",x);
return 0;
}
and it works fine; I get 5 as answer for "aqr b qabxx xryc pqr". But I need my program written only using assembly code. Something like this:
.intel_syntax noprefix
.globl main
.text
main:
mov ecx,?
?<- here is the issue: I don't know how to get an argument from the command line and access it as a char *.
xor edx,edx
jmp petla
petla0:
inc ecx
petla:
cmp byte ptr [ecx],0
jz wyjscie
cmp byte ptr [ecx],32
jz petla0
inc edx
petla1:
inc ecx
cmp byte ptr [ecx],0
jz wyjscie
cmp byte ptr [ecx], 32
jz petla
jmp petla1
wyjscie:
push edx
push offset msg
call printf
add esp, 8
mov edx,0
ret
.data
msg: .ascii "number of words=%d\n"

Answer 1

So first, let's look at your "working" code. While it works, there are a few "teachable" items here.
First of all, please get in the habit of using comments in your code. I realize English is not your first language so I probably couldn't read your comments, but still, you should have them.
Second, stop using ; to terminate your asm instructions. Yes, it looks a little clunkier to use \n\t, but when you use gcc's -S to output the assembler (a great way to see what's really going on), your code will be a mess without \n\t.
So far, that gets us:
asm volatile(
".intel_syntax noprefix\n\t"
// %1 is read-only, so use eax as temp
"mov eax,%1\n\t"
// # of words found
"xor edx,edx\n\t"
"jmp petla\n"
// Skip over spaces
"petla0:\n\t"
"inc eax\n"
"petla:\n\t"
"cmp [eax],byte ptr 0\n\t"
"jz wyjscie\n\t" // End of string
"cmp [eax],byte ptr 32\n\t"
"jz petla0\n\t" // Another space
// Starting new word
"inc edx\n"
// Walk the rest of the current word
"petla1:\n\t"
"inc eax\n\t"
"cmp [eax],byte ptr 0\n\t"
"jz wyjscie\n\t" // End of string
"cmp [eax],byte ptr 32\n\t"
"jz petla\n\t" // End of word
"jmp petla1\n" // Not end of word
"wyjscie:\n\t"
"mov %0,edx\n\t"
".att_syntax prefix"
: "=r" (x)
: "r" (s)
: "eax","edx"
);
Third, you need to understand that when using extended asm, %0 is just a way to refer to whatever is being passed in as the first argument. In this case, you specify that it must be a register ("=r"). So the value is already a register. Instead of using both edx and %0, you can store the count directly in %0.
Fourth, the purpose of byte ptr is so the assembler knows whether [eax] means: The byte at [eax], the word as [eax], the dword at [eax], etc. Such being the case, it is more commonly placed on the other side of a cmp instruction:
asm volatile(
".intel_syntax noprefix\n\t"
// %1 is read-only, so use eax as temp
"mov eax,%1\n\t"
// # of words found
"xor %0,%0\n\t"
"jmp petla\n"
// Skip over spaces
"petla0:\n\t"
"inc eax\n"
"petla:\n\t"
"cmp byte ptr [eax], 0\n\t"
"jz wyjscie\n\t" // End of string
"cmp byte ptr [eax], ' '\n\t"
"jz petla0\n\t" // Another space
// Starting new word
"inc %0\n"
// Walk the rest of the current word
"petla1:\n\t"
"inc eax\n\t"
"cmp byte ptr [eax], 0\n\t"
"jz wyjscie\n\t" // End of string
"cmp byte ptr [eax], ' '\n\t"
"jz petla\n\t" // End of word
"jmp petla1\n" // Not end of word
"wyjscie:\n\t"
".att_syntax prefix"
: "=r" (x)
: "r" (s)
: "eax","edx"
);
What's next? Oh yeah. When you use jz or jnz, if it doesn't jump, the code falls thru to the next instruction. This means that this:
"cmp byte ptr [eax], 0\n\t"
"jz wyjscie\n\t" // End of string
"cmp byte ptr [eax], ' '\n\t"
"jz petla\n\t" // End of word
"jmp petla1\n" // Not end of word
"wyjscie:\n\t"
Can be done like this:
"cmp byte ptr [eax], 0\n\t"
"jz petla\n\t" // End of word
"cmp byte ptr [eax], ' '\n\t"
"jnz petla1\n\t" // Not end of string
"wyjscie:\n\t"
As a general rule, I avoid doing memory reads multiple times. So where you do:
"cmp byte ptr [eax], 0\n\t"
"cmp byte ptr [eax], ' '\n\t"
I would do:
"mov dl, [eax]\n\t"
"cmp dl, 0\n\t"
"cmp dl, ' '\n\t"
This also lets us get rid of the byte ptr. dl can only hold a byte, so that must be what we are reading.
Another subtle point: In your original code, when you are walking the letters, if you encounter a space, you jump back to petla, where you check again to see if it is a space instead of to petla0 to read the next byte.
And 2 other nits: When comparing something with zero, I use test instead of cmp (generates slightly better code). And while it does exactly the same thing, when I compare 2 values (cmp edx, ' '), I find it easier to think in terms of "Are these things 'equal'" rather than "Is the difference between them zero?" As a result, I would use je instead of jz.
Putting all this together gives me:
asm (
".intel_syntax noprefix\n\t"
// %1 is read-only, so use eax as temp
"mov eax, %1\n\t"
// # of words found
"xor %0,%0\n"
// Skip over spaces
"petla0:\n\t"
"mov dl, [eax]\n\t"
"inc eax\n\t"
"test dl, dl\n\t"
"jz wyjscie\n\t" // End of string
"cmp dl, ' '\n\t"
"je petla0\n\t" // Another space
// Starting new word
"inc %0\n"
// Walk the rest of the current word
"petla1:\n\t"
"mov dl, [eax]\n\t"
"inc eax\n\t"
"cmp dl, ' '\n\t"
"je petla0\n\t" // end of word
"test dl, dl\n\t"
"jnz petla1\n" // not end of string
"wyjscie:\n"
".att_syntax prefix;"
: "=r" (x)
: "r" (s)
: "eax", "edx", "cc", "memory"
);
I also removed the volatile. Since you are using the output (by printing x), this is not required.
I will let you roll any of this that you want to keep into your pure asm by yourself.
As for why your pure asm doesn't work, I'm not on linux, so I can't run this. However, I don't see anything actually wrong with your counting code. You might look at this for accessing the command line arguments, but what you are doing should not give you 1.
How are you specifying your command line? I suspect you are not using the " marks around your string: a.out " aqr b qabxx xryc pqr". This would cause each word to be treated as a separate (null terminated) argument.
Edit 1: After some more reading, it looks like the pointer to argv[1] really should be at [esp + 8]. At least on linux. You aren't on Windows, right? Pretty sure it uses a different scheme.
You can try this to make sure your asm is working correctly, but I'm pretty sure that isn't your problem.
lea ecx, str
// Down by .data add:
str: .ascii " asdf adfs asd f adsf "
You can try using the msg format string you have to print argc. If you are passing the arguments correctly, this should be 2.
Change your msg to use %s, and print out the value from argv[0] (aka [esp+4]). This should be the program name.
Using that %s, you can print out argv[1].