ARM C embedded asm writing

I've been playing around with an E2 phone recently, and I want to port C/Invoke ( http://www.nongnu.org/cinvoke/ ) to the E2, which has an arm CPU and Linux system. I downloaded the source code and followed the instructions to add a gcc_arm_linux arch file, but when I was modifying it, I found that there was asm code in it. I had never done this before, and I couldn't understand it at all. So, I looked up the "ARM Instruction Set" on the Internet and found the instructions I needed. The instructions were simple, but I was confused by the way of writing asm embedded in c. I also looked up the "AT&T ASM Reference", and only then did I deal with several embedded ARM assembly macros in the code. Part of the code:

/////////////////////////////////////
// macros
/////////////////////////////////////

// the following examples are given
// for x86 in MASM syntax.  Some of these
// macros might not need to be implemented
// in inline assembly, depending on the arch,
// but likely most of them will.

// this macro stores the values in the input
// registers in the ArchRegParms structure passed as 'regparms'.
// In the example below we store ecx and edx because
// they are used in the fastcall convention to pass
// parameters.

// 存储“输入寄存器”中的值到regparms中。

#define ARCH_SAVE_REGPARMS(regparms) 
    __asm__("str %%r0, %0; 
        str %%r1, %1; 
        str %%r2, %2; 
        str %%r3, %3; 
        str %%r4, %4; 
        str %%r5, %5; 
        str %%r6, %6; 
        str %%r7, %7;" : 
            "=m" ((regparms).a1), 
            "=m" ((regparms).a2), 
            "=m" ((regparms).a3), 
            "=m" ((regparms).a4), 
            "=m" ((regparms).d0), 
            "=m" ((regparms).d1), 
            "=m" ((regparms).d2), 
            "=m" ((regparms).d3) :: );

// this macro does two things: copies the values
// stored in regparms into the input registers,
// and calls the function pointed to by the pointer
// ep.

// 复制regparms中的值到“输入寄存器”中，并调用指针ep指向的函数。

#define ARCH_CALL(regparms, ep) 
    __asm__("ldr %%r0, %0; 
        ldr %%r1, %1; 
        ldr %%r2, %2; 
        ldr %%r3, %3; 
        ldr %%r4, %4; 
        ldr %%r5, %5; 
        ldr %%r6, %6; 
        ldr %%r7, %7; 
        ldr %%r8, %8; 
        bx %%r8;" :: 
            "m" ((regparms).a1), 
            "m" ((regparms).a2), 
            "m" ((regparms).a3), 
            "m" ((regparms).a4), 
            "m" ((regparms).d0), 
            "m" ((regparms).d1), 
            "m" ((regparms).d2), 
            "m" ((regparms).d3), 
            "m" (ep) : 
            "r0", 
            "r1", 
            "r2", 
            "r3", 
            "r4", 
            "r5", 
            "r6", 
            "r7", #define ARCH_SAVE_RETURN(archvalue, type) // Saves any possible return value in archvalue.// structure given by archvalue.// saves any possible return values ​​in the ArchRetValue
            "r8");









    __asm__("str %%r0, %0; 
        str %%r1, %1; 
        str %%r4, %2;" : 
            "=m" ((archvalue).a1), 
            "=m" ((archvalue).a2), 
            "=m" ((archvalue).d0) :: );


// stores the return values in the ArchRetValue structure
// into any place where a caller might expect to find them

// 存储archvalue中的值到“调用者”能找到的地方(寄存器)。

#define ARCH_SET_RETURN(archvalue, type) 
    __asm__("ldr %%r0, %0; 
        ldr %%r1, %1; 
        ldr %%r4, %2;" :: 
            "m" ((archvalue).a1), 
            "m" ((archvalue).a2), 
            "m" ((archvalue).d0) : 
            "r0", 
            "r1", 
            "r4");



// increases the stack size by bcount bytes
#define ARCH_PUT_STACK_BYTES(bcount) 
    __asm__("ldr %%r8, %0; 
                sub %%sp, %%sp, %%r8;" :: 
                    "m" (bcount) : 
                    "r8", 
                    "sp");

// decreases the stack size by bcount bytes
#define ARCH_REMOVE_STACK_BYTES(bcount) 
    __asm__("ldr %%r8, %0; 
                add %%sp, %%sp, %%r8;" :: 
                    "m" (bcount) : 
                    "r8", 
                    "sp");

// copies the current stack pointer into the pointer variable
// stackp
#define ARCH_GET_STACK(stackp) 
    __asm__("str %%r13, %0;" : "=m" (stackp) :: );


// copies the current frame pointer into the pointer variable
// framep
#define ARCH_GET_FRAME_PTR(framep)     
    __asm__("str %%r11, %0;" : "=m" (framep) :: );

Let's mainly talk about the embedded writing method of AT&T ASM. The format is as follows:
__asm__("instruction": "operation constraint" (output parameter): (input parameter): register constraint);

Instruction: Of course, it is the ARM assembly instruction, but it should be noted that the register must be constrained with %% to prevent conflict with parameter %.

Operation Constraint: I personally understand it as a parameter passing method, such as "=m", where "=" indicates output, and can be omitted to indicate input, "+" indicates both input and output, and "m" indicates the use of memory. In x86, it can also be "a", "b", "c", etc., indicating what kind of register to use.

Output parameter: corresponds to the variable in C code, and is the value taken from the register or memory by the assembly code for use in C code. When there are multiple parameters, separate them with commas.

Input parameters: Parameters that C code inputs to assembly code.

Register Constraint: I think it is for the compiler to check your code and prevent you from modifying the contents of registers that should not be modified.

In ARM, registers are different from those on X86. There is no ax, bx, etc. It is r0~r15, which also includes several special-purpose registers, such as: r11=fp (frame pointer), r13=sp (stack pointer), etc.