如果使用 Intel 语法，GAS 可以在非 Intel 系统上组装吗？

Question

Can I use the Intel syntax with GAS (GNU Assembler) if I assemble on non-Intel systems?

Essentially, I am starting out with assembly programming though I have many years of experience in higher-level languages and I would like to choose an assembler that is suitable for both x86 and ARM. Possibly other architectures as well but this is not a pressing need right now.

So far I have been happy with NASM but I also need ARM so GAS seems a nice candidate. Not having written anything much complex yet I am equally open to AT&T as well as to Intel syntax.

The only thing I am not sure if can I use GAS for cross-architecture programming as well if I pick the Intel syntax?

I realise that naturally instruction sets will be different but I would just like to settle on one tool to cover both the architectures - my thinking is that if with time I need a third one there will be less tooling to learn and maintain if I just do everything in GAS from day one.

Intuitively, I would say that there should not be any obstacles to using Intel syntax instead of AT&T to assemble programs on ARM or other non-Intel architectures, because GAS likely builds AST and then emits architecture-specific code regardless of the frontend's syntax, but unfortunately I do not have access to an ARM system to try it out and, that notwithstanding, I would very much like to confirm it with more knowledgeable people. Thank you.

EDIT: I came up with an analogy that may perhaps make it clearer what I have in mind. Supposing that someone learns to use vim effectively on Linux to work with Python, all that knowledge will transfer easily to Mac for development with Objective-C.

Needless to say, Python and Objective-C are two distinctly different languages but still, the knowledge of tooling (vim, in this example) will be useful.

If one day the person needs to develop Java on Windows, the same will still hold and the programmer will be able to use vim or a derivative on the third system.

Ultimately, the actual differences between the languages, Python vs. Obj-C vs. Java will naturally dwarf any tooling-related issues but when someone is just starting out, the idea of using the same tool for several different needs is quite appealing.

This is the kind of reusability that I am thinking of.

Answer 1

Some of your intuition is right. Gas certainly does support multiple architectures , and there are core features like assembler directives which will enable you to transfer some working knowledge between architecture ports of Gas. Certain command line concepts will be shared; others will differ by what the architecture port maintainers were thinking at the time.

Other aspects of your question, particularly the question of AT&T syntax versus Intel syntax are not well placed for the question you're asking. I prefer to think of these as dialects of x86 with the challenge being learning the instruction set. What you're asking with respect to changing architecture is more fundamental; you're going to learn a new “language” each time, with Gas directives like .balign acting like the only common punctuation marks between those languages.

Gas does require building a separate version for each architecture you want to target. On any individual system, you are probably operating “natively” as in your want to write assembler for your current machine. That's not the only way to use Gas, so one way to “trial” it if you don't have an Arm machine to hand would be to install a cross-assembler (for example, on Ubuntu https://packages.ubuntu.com/focal/binutils-arm-linux-gnueabi ).

Answer 2

I would like to choose an assembler that is suitable for both x86 and ARM

What exactly do you want to do?

1. Writing programs on an ARM computer (in x86 syntax!) that shall later run on an x86 PC or writing programs on an x86 PC (in ARM syntax!) that shall later run on an ARM CPU?
2. Writing assembly programs that shall run both on an ARM and on an x86 PC?

If the answer is 1.:

Many CPUs in smaller devices (for example WLAN routers or smartpones) are ARM CPUs. However, you want to develop programs for such devices on your PC, which has an x86 CPU.

What you do is using a GAS version with the "target" ARM and the "host" x86. This means that GAS is running on an x86 CPU but generates code for an ARM CPU.

However, your "source code" (assembly program) must be an ARM assembly program.

As far as I know, GAS supports only one syntax variant for ARM CPUs; there is nothing like the "AT&T" syntax for ARM.

If you have an ARM computer and you want to write x86 programs on it, you can of course use a GAS version with the "target" x86 and the "host" ARM. If the "target" is x86, GAS supports "AT&T" and "Intel" syntax independently of the "host".

If the answer is 2.:

This won't work!

In assembly language, one assembly instruction typically represents one instruction of the CPU. And different CPU architectures have completely different instructions and therefore completely different assembly code.

Here an example program for x86 and for ARM:

Intel CPU, Intel syntax         ARM (non-Thumb) CPU
-----------------------         -------------------
mov eax, 4
mov ebx, 1                      ldr r0, =1
mov ecx, offset myText          ldr r1, =myText
mov edx, 6                      ldr r2, =6
int 0x80                        svc #0x900004

shr edi, 6
add eax, edi                    add r0, r0, r6, lsr #6

                                ldr r5, =someVariable
add [someVariable], eax         ldr r7, [r5]
                                add r7, r0
                                str r7, [r5]

You can see that there is no 1:1 relation for the instructions:

The instruction add [someVariable], eax on the x86 requires 4 instructions on the ARM; the instruction add r0, r0, r6, lsr #6 on the ARM requires 2 instructions on the x86.