Introduction to ARM GNU Common Assembly Language

ARM assembly language source program statements are generally composed of instructions, pseudo operations, macro instructions and pseudo instructions.
The design basis of ARM assembly language is assembly pseudo-instructions, assembly pseudo-operations and macro instructions.

Pseudo operations are some special instruction mnemonics in ARM assembly language programs. Their main function is to make various preparations for completing the assembly program.
The source program is processed when the assembler is run, but there is no machine execution during the computer operation. In other words, these pseudo operations only work during the assembly process.
Once the compilation is finished, the purpose of the pseudo operation disappears.

A macro instruction is an independent piece of program code that can be inserted into a program and is defined through pseudo-operations.
    1>Macros must be defined in advance before they are used. Macros can call each other and can also call themselves recursively.
    2>Use the macro by directly writing the macro name and input and output parameters in the format of macro instructions.
    3>The macro definition itself does not generate code, but inserts the macro body into the original program when calling it.
    4>Macro is similar to the calling of sub-function parameters and actual parameters in C language. When calling macro, actual instructions are used to replace the macro body to implement a related section of code. However, there is an essential difference between macro calling and subroutine calling, that is, macro does not save program space. Its advantages are to simplify program code, improve program readability, and macro content can be modified synchronously.
      Pseudo-operations and macro instructions are generally related to compilers, so the pseudo-operations and macro instructions of ARM assembly language have different writing forms and rules in different compilation environments.
      Pseudo-instructions are also special mnemonics in ARM assembly language programs, and are not executed by the machine during the operation of the processor. They will be replaced by appropriate machine instructions into ARM or Thumb instructions during assembly, thereby realizing the real instruction operation.
        
There are currently two commonly used ARM compilation environments:
    1>ADS/SDT IDE: developed by ARM, using the CodeWarrior compiler.
    2> An IDE development environment that integrates GNU development tools; it consists of the GNU assembler as, the cross assembler gcc, and the linker id.
      For ARM pseudo-operations and macro instructions in the ADS compilation environment, please refer to "ARM Microcontroller Fundamentals and Practice" (by Zhou Ligong) published by Beihang University Press. This mainly describes the commonly used ARM GNU assembly language.
    
4.1 Introduction to ARM GNU Common Assembly Pseudo-Instructions
    1.abort
     .abort: stop compilation
     .align absexpr1,absexpr2:
      Fill unused memory area with values ​​at a certain alignment. The first value indicates the alignment, 4, 8, 16 or 32. The second expression value indicates the value to fill.
    2.if...else...endif
     .if
     .else
     .endif: Support conditional precompilation
    3.include
     .include "file": Include the specified header file. You can put an assembly constant definition in the header file.
    4.comm
     .comm symbol, length: Apply for a namespace in the bss segment. The name of the space is symbol and the length is length.
      Make room for it.
    5.data
     .data subsection: Indicates that the following definition belongs to the subsection data segment.
    6.equ
     .equ symbol, expression: defines a symbol as a value (expression). This instruction does not allocate space.
    7.global
     .global symbol: defines a global symbol, usually used by ld.
    8.ascii
     .ascii "string": defines a string and allocates space for it.
    9.byte
     .byte expressions: define a byte and allocate space for it.
    10.short
      .short expressions: Define a short integer and allocate space for it.
    11.int
      .int expressions: Define an integer and allocate space for it.
    12.long
      .long expressions: Define a long integer and allocate space for it.
    13.word
      .word expressions: define a word and allocate space for it, 4 bytes.
    14.macro/endm
      .macro: defines a macro code, .macro indicates the beginning of the code, and .endm indicates the end of the code.
    15.req
      name .req register name: Define an alias for the register.
    16.code
      .code [1632]: specifies the length of the instruction code generated, 16 for Thumb instructions, 32 for ARM instructions.
    17.ltorg
      .ltorg: Indicates that the next definition is attributed to the current segment and space is allocated for it.

 

4.2 ARM GNU-specific symbols
    1.@
       The characters representing a comment from the current position to the end of the line.
    2.#
        Comment out an entire line.
    3.;
        New line separator.
      
4.3 Operation Code
    1. NOP
       nop
       No operation, equivalent to MOV r0, r0
    2.LDR
      ldr  , = 
      Equivalent to a long transfer of the PC register or other registers.
    3.ADR
      adr  
      Small range transfer relative to PC register or other registers.
    4.ADRL
      adrl  
      Transfer relative to the PC register or its range.
    5. Executable generation instructions
      5.1 lds file description
      5.1.1 Description of main symbols
      1. OUTPUT_FORMAT(bfdname)
        Specify output executable file format.
      2. OUTPUT_ARCH(bfdname)
        Specify the CPU platform on which the output executable file runs
      3. ENTRY(symbol)
        Specify the entry segment of the executable file
        5.1.2 Segment Definition
        1. Segment definition format
            SECTIONS
            { ...
                Section Name:
                {
                    content
                }
            ...
            }