1. Evolution of Modular Programming

In assembly language development, code reuse techniques have undergone three main stages of development:

1. Source File Inclusion (INCLUDE) – The most basic method of reuse
2. Object Module Linking – Intermediate reuse solution
3. Subroutine Libraries – The most efficient reuse mechanism

2. Comparative Analysis of Three Implementation Methods

2.1 Source File Inclusion Method

Implementation Method:

; main.asm
INCLUDE "subroutines.inc"

_start:
    CALL Delay1s
    CALL UART_Send

Advantages:

• Simple and intuitive implementation
• No additional operations required after modifying subroutines

Disadvantages:

• High risk of symbol conflicts
• All subroutines need to be reprocessed with each assembly
• No selective inclusion

2.2 Object Module Linking Method

Implementation Steps:

1. Assemble subroutine modules separately:

; subs.asm
PUBLIC Delay1s, UART_Send

Delay1s PROC FAR
    ; Delay implementation
    RET
Delay1s ENDP

UART_Send PROC FAR
    ; UART send implementation
    RET
UART_Send ENDP

1. Main program declares external symbols:

; main.asm
EXTRN Delay1s:FAR, UART_Send:FAR

_start:
    CALL Delay1s
    CALL UART_Send

1. Assemble and link separately:

masm main.asm;
masm subs.asm;
link main.obj+subs.obj;

Advantages:

• Avoids symbol conflicts
• Only the modified subroutine module needs to be reassembled
• Clear interface declarations

Disadvantages:

• Unused subroutines may still be included in the final program
• Managing multiple object files can be complex

2.3 Subroutine Library Method

**Library Creation Example (MASM)**:

lib /OUT:utils.lib subs.obj other.obj

Main Program Usage:

; main.asm
EXTRN Delay1s:FAR, UART_Send:FAR

_start:
    CALL Delay1s
    CALL UART_Send

Link Command:

link main.obj utils.lib

Advantages:

• Automatically selects required subroutines
• Reduces the final program size
• Professional library management

Disadvantages:

• Requires additional library management tools
• Debugging information may be incomplete

3. Technical Implementation Details

3.1 Symbol Management Mechanism

PUBLIC/EXTRN Instruction Explanation:

; Declare public symbols in subroutine module
PUBLIC Func1, Var1

; Declare external references in main module
EXTRN Func1:NEAR, Var1:WORD

Type Specifiers:

• NEAR – Near call (within the same segment)
• FAR – Far call (across segments)
• BYTE/WORD/DWORD – Data size

3.2 Parameter Passing Conventions

Register Parameter Passing Example:

; Caller
MOV AX, 1234h
MOV BX, 5678h
CALL AddNumbers

; Subroutine module
AddNumbers PROC
    ADD AX, BX
    RET
AddNumbers ENDP

Stack Parameter Passing Example:

; Caller
PUSH 1234h
PUSH 5678h
CALL FarAdd
ADD SP, 4

; Subroutine module
FarAdd PROC FAR
    PUSH BP
    MOV BP, SP
    MOV AX, [BP+6] ; First parameter
    ADD AX, [BP+4] ; Second parameter
    POP BP
    RET
FarAdd ENDP

3.3 Segment Definition Strategies

**Small Model (Single Code Segment)**:

; Main module
_TEXT SEGMENT WORD PUBLIC 'CODE'
    ASSUME CS:_TEXT
    EXTRN Sub1:NEAR
_start:
    CALL Sub1
_TEXT ENDS

; Submodule
_TEXT SEGMENT WORD PUBLIC 'CODE'
    ASSUME CS:_TEXT
    PUBLIC Sub1
Sub1 PROC NEAR
    RET
Sub1 ENDP
_TEXT ENDS

**Large Model (Multiple Code Segments)**:

; Main module
MAIN_SEG SEGMENT PARA PUBLIC 'CODE'
    ASSUME CS:MAIN_SEG
    EXTRN Sub1:FAR
_start:
    CALL FAR PTR Sub1
MAIN_SEG ENDS

; Submodule
SUB_SEG SEGMENT PARA PUBLIC 'CODE'
    ASSUME CS:SUB_SEG
    PUBLIC Sub1
Sub1 PROC FAR
    RET
Sub1 ENDP
SUB_SEG ENDS

4. Extended Features of Modern Assemblers

4.1 Intelligent Library Management

**Example (NASM Syntax)**:

; Using %include with macro definitions
%define USE_UART 1
%define USE_TIMER 1

%if USE_UART
    %include "uart.inc"
%endif

%if USE_TIMER
    %include "timer.inc"
%endif

4.2 Conditional Assembly Techniques

; Select implementation based on target platform
%ifdef WINDOWS
    Extrn _printf:NEAR
%else
    Extrn printf:NEAR
%endif

4.3 Dynamic Linking Support

; Call functions in DLL
Import MessageBoxA user32.dll
Import ExitProcess kernel32.dll

_start:
    Push 0
    Push caption
    Push message
    Push 0
    Call [MessageBoxA]
    Call [ExitProcess]

5. Performance Optimization Suggestions

1. Hot Subroutine Layout:

   ; Place frequently called subroutines in the same code page
   ALIGN 16
   HotSubroutine1:
       ; ...
       RET
   
   ALIGN 16
   HotSubroutine2:
       ; ...
       RET
   

2. Calling Convention Optimization:

   ; Minimize saving/restoring using registers
   FastCallSub PROC
       PUSH CX       ; Only save the registers that are modified
       ; ...
       POP CX
       RET
   FastCallSub ENDP
   

3. Library Organization Strategies:

• Organize libraries by function (IO.lib, MATH.lib, etc.)
• Organize libraries by call frequency (common.lib, extended.lib)
• Organize libraries by CPU features (SSE.lib, AVX.lib)

6. Debugging and Maintenance Tips

1. Version Control Markers:

   ; Add version information in library module
   SECTION .version
   LibVersion DB "GPIO_LIB v1.2.3",0
   BuildDate  DB __DATE__ " " __TIME__,0
   

2. Retain Debug Information:

   # Generate debug information during assembly
   nasm -f win32 -g -F cv8 -o lib.obj lib.asm
   

3. Dependency Check:

   # Makefile Example
   app.exe: main.obj utils.lib
       link /DEBUG /OUT:app.exe main.obj utils.lib
   
   utils.lib: gpio.obj uart.obj
       lib /OUT:utils.lib gpio.obj uart.obj
   

7. Cross-Platform Compatibility Solutions

Abstract Interface Example:

; Define standard interface
Interface SEGMENT
    ; Input: AX=parameter1, BX=parameter2
    ; Output: AX=result
    StdCall MACRO func
        IFDEF WINDOWS
            PUSH BX
            PUSH AX
            CALL func
            ADD SP,4
        ELSE
            CALL func
        ENDIF
    ENDM
Interface ENDS

Through systematic modular design and library management, assembly language development can achieve a level of code reuse close to that of high-level languages while maintaining precise control over hardware. The key lies in establishing clear interface specifications, adopting reasonable organizational strategies, and fully utilizing the capabilities of modern assemblers.