5

how do I translate mov [ebx], al from NASM to GAS? I tried mov %al, (%ebx) but it does segmentatiob fault.

Another question, lets say I have an array in GAS .lcomm array, 50 Do I have to put a dollar($) sign in array like this: mov %rbx, $array or need not to?

Any answer would be helpful :)

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
ThisGuy
  • 833
  • 1
  • 9
  • 19
  • Assemble with NASM, disassemble with `objdump -d` (or with [`objconv`](http://www.agner.org/optimize/#objconv) to get a file you can actually assemble. – Peter Cordes Dec 27 '17 at 07:10

4 Answers4

3

How about intel2gas?

usage: intel2gas [options] [-o outfile] [infile]
where options include:
    -h        this help
    -i        convert from intel to at&t format (default)
    -g        convert from at&t to intel format
    -m -t     convert from masm/tasm to at&t format
    -c        understand C style comments
    -I        convert inline assembler (intel to at&t only)
    -d        output all % chars as %%
    -V        show version
    infile and outfile default to stdin/stdout
Lain-dono
  • 31
  • 3
2

Assemble with NASM, disassemble with objdump -d to get the AT&T syntax version of any single instruction.

Or use Agner Fog's objconv to disassemble to a .S file with GAS AT&T syntax you can actually assemble directly. (it puts labels on branch targets). It still doesn't really handle converting data, though, mostly code I think.

BTW, with GAS you can use .intel_syntax noprefix, but it's MASM-style not NASM, so mov eax, symbol is a load, not a mov-immediate of the address. (You'd need mov eax, OFFSET symbol in GAS .intel_syntax). See https://stackoverflow.com/tags/intel-syntax/info for more about the differences between NASM and MASM.

mov [ebx], al and mov %al, (%ebx) are the same instruction: a one-byte store of al using the ebx alone as the address. If that segfaulted, then that instruction alone isn't the problem. Either other instructions are wrong, or you have a different kind of problem. Perhaps you assembled your GAS code as 64-bit? Assembling 32-bit binaries on a 64-bit system (GNU toolchain).

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
1

you can use objdump (otool on osx) to disassemble into gas format.

Camden
  • 283
  • 2
  • 15
  • It's Intel-syntax, but it's MASM-style, not NASM. e.g. `mov eax, symbol` is a load from memory in GAS and MASM, but a `mov`-immediate of the address in NASM. See https://stackoverflow.com/tags/intel-syntax/info. – Peter Cordes Dec 27 '17 at 07:06
0

First up, mov %al, %ecx can't really fault because it's not accessing memory. Hell, it shouldn't even assemble because they are of different size. That said, the correct translation of your nasm code is mov %al, (%ecx) which will write al into memory at address ecx.

For the other question: you need the $ if you want to reference the address. As such, mov %rbx, $array is invalid because you can't assign to the address. If you want to store rbx into the first item of the array, write mov %rbx, array. If you want to load the first item, use mov array, %rbx. If you want to load the address of the first item, do mov $array, %rbx or use lea which is special and doesn't need the $.

Jester
  • 56,577
  • 4
  • 81
  • 125
  • Nice, thanks. sorry I have missed something. I tried that, it worked for ecx but not for ebx. I have tried mov %al, (%ebx) and movb %al, (%ebx), still does seg fault. What do I do? – ThisGuy Sep 16 '13 at 17:55
  • That means `ebx` has an invalid address. Maybe you didn't load it with an address. I can only guess without seeing the whole code. Also, it it's supposed to be 64 bit code, `ebx` feels wrong. – Jester Sep 16 '13 at 18:02
  • Well, I did something like: push %ebx and pop %ebx then after pop, it does seg fault. Is there something wrong? – ThisGuy Sep 16 '13 at 18:07