用ARM汇编语言求x以内素数之和

如有错误，欢迎指正😝

最简单的方法是写一个c/c++语言程序，然后在汇编语言文件中调用
但是本文主要用于练习汇编语言，故用纯汇编语言编写。

题目要求：用汇编语言求x以内素数之和

知识点：
什么是素数？
在所有比1大的整数中,除了1和它本身以外,不再有别的约数,这种整数叫做质数或素数.还可以说成质数只有1和它本身两个约数

方法一：用x整除2~x-1，找出所有素数并相加

== 缺点：循环调用量大，耗时，不推荐！==
C++版本（以100为例）：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main()
{
    int sum=0;

    vector<int> obj;
    for(int i=2;i<=100;i++)
    {
        int flag=1;//flag标志是否为素数，1表示是素数，0表示不是
        for(int j=2;j<i;j++)//判断是否还有其他因子
        {
            if(i%j==0)
            {
                flag=0;
                break;
            }
        }
        //如果是素数放入数组中

        if(flag==1)
        obj.push_back(i);

    }
    for(int i=0;i<obj.size();i++)
     {
         cout<<obj[i]<<' ';
         sum+=obj[i];
    }
    cout<<endl<<sum;

    return 0;
}

结果：

1.首先得编写一个函数判断a是否为b的倍数

/*
	return 1: a是b的倍数
	return 0: a不是b的倍数
*/
int Is_Multi(int a, int b) 3,2
{
	int i = b; 2
	
	while (b <= a)
	{
		if (a == b)
		{
			return 1;
		}
		b = b + i;
	}

	return 0;
	
}

汇编:

Is_Multi  PROC
	; 现场保护
	PUSH {R2-R12, LR}
	; 函数的具体实现
		; R3 -> a
		; R1 -> b
		;循环初始化   R0, R1, R2保存原始的R1值
		MOV R2, R1
		MOV R3, R0
		MOV R0, #0 ; //默认不是倍数
loop
	CMP R3, R1    a--b
	BLT loop_end
	MOVEQ R0, #1
	BEQ loop_end
	ADD R1, R1, R2
	B loop	
loop_end		
	; 现场恢复
	POP {R2-R12, PC}
	ENDP

eg:判断10是否为3的倍数

2.其次用汇编语言实现一个函数，判断一个数x是否为质数

C++版本：

int Is_Prime(int x)
{
	int i ;
	
	for (i = 2; i < x; i++)
	{
		if (Is_Multi(x, i))
		{
			return 0;
		}
	}
	
	return 1;
}

汇编：

Is_Prime  PROC
		;现场保护
	PUSH {R1-R12, LR}
			
		;具体的实现
			; x -> R3
			; i -> R4
			MOV R3, R0
			MOV R4, #2
			MOV R5, #1 ;//函数的返回值，初始化是质数
loop_x
	  ; i < x
	  CMP R4, R3
	  BGE loop_x_end；//大于等于跳转
	  
	  MOV R0, R3
	  MOV R1, R4
	  BL Is_Multi
	  
	  CMP R0, #1；//是倍数
	  MOVEQ R5, #0；//不是质数
	  BEQ loop_x_end

	  ADD R4, R4, #1
	  B loop_x

loop_x_end
	  MOV R0, R5; 函数的返回值，要保存在R0中
		;现场恢复					
	POP {R1-R12, PC}
	ENDP

eg：判断5是否为质数

3.最后才是用汇编语言实现x以内所有素数之和

汇编：
该方法没有开辟数据段，所以保护现场只保护了不用的😁
也可以使用数组的方法将所有质数保存在数组中，该方法可以开辟数据段，有一个好处是知道都有哪些质数，在下一个方法中演示

Stack_size EQU 0x200	
	AREA mSTACK,NOINIT,READWRITE,ALIGN=3;

STACK_Mem
	SPACE Stack_size;
_init_msp;


	AREA RESET,DATA, READONLY;
_Vectors
	DCD _init_msp;
	DCD _start;
	SPACE 0X400		
	AREA mCODE,CODE,READONLY
		
_start	PROC
	BL prime_sum
	B .
	ENDP
		
		
Is_Multi  PROC
	PUSH {R8-R12, LR}
	MOV R2, R1
	MOV R3, R0
	MOV R0, #0 
loop
	CMP R3, R1
	BLT loop_end
	MOVEQ R0, #1
	BEQ loop_end
	
	ADD R1, R1, R2
	B loop

loop_end
	POP {R8-R12, PC}
	ENDP
		
		
		
Is_Prime  PROC
	PUSH {R8-R12, LR}
	MOV R3, R0;x->R3
	MOV R4, #2;i->R4
	MOV R5, #1;R5表示是否为质数，1表示是，0表示不是，初始化为是质数
loop_x
	  CMP R4, R3
	  BGE loop_x_end
	  
	  MOV R0, R3
	  MOV R1, R4
	  BL Is_Multi
	  
	  CMP R0, #1
	  MOVEQ R5, #0
	  BEQ loop_x_end

	  ADD R4, R4, #1
	  B loop_x
loop_x_end
	POP {R8-R12, PC}
	ENDP
		
		
		
prime_sum PROC
	PUSH {R8-R12, LR}
	MOV R0,#2
loop_y;如果R3是质数，R6+=+R3
	BL Is_Prime
	CMP R5,#0
	BEQ loop_y_end
	
	ADD R6,R6,R3;R6存储质数和
	B loop_y_end
	
loop_y_end;如果不是质数，判断下一个数，直到100
	ADD R0,R3,#1
	CMP R0,#100
	BLE loop_y	
	POP {R8-R12, PC}	
	ENDP
		
	END

结果：

但是如果x=1000000呢？
此时循环两较大，非常耗时，因此采用下面这种方法

方法二：x整除<x的所有素数

C++版本：

for (x = 2; x <= 100; x++)
{
	for (i = 0; i < i_a; i++)
	{
		if (x % a[i] == 0)
		{
			break;
		}
	}
	
	if (i == i_a)
	{
		a[i_a++] = x;
		sum += x;
	}
}

由C++转向汇编

for (R7 = 2; R7 <= R4; R7++)
{	
	for (R8 = 0; R8 < R6; R8++)
	{
		if (Is_Multi(R7, prime[R8]))
			{
				break;
			}
	}
	if (R8 == R6)
	{
		R5 += R7;
		prime[R6 ++] = R7;
}

汇编语言：

Stack_size EQU  0x200
	
	AREA  mSTACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem
	SPACE Stack_size  
__init_msp	

	AREA RESET,DATA, READONLY 
__Vectors
	DCD __init_msp 
	DCD __start		
	SPACE 0x400
;定义数据段
	AREA xData,DATA, READWRITE
prime;标号,一个标号指代了一个地址
	SPACE 400		;大小为400，应为最多有100个素数，每个占4byte

;定义代码段
	AREA mCODE, CODE, READONLY
__start		PROC
	MOV R0,#100
	BL prime_sum
	B .
	ENDP
		
prime_sum PROC
	PUSH {R1-R12, LR}
	MOV R6, #0 ;素数数组个数
	MOV R4, R0 ;x->R4
	MOV R5, #0 ;sum -> R5
	MOV R7, #2 ;i
loop_2;对应C++中的外循环
	CMP R7, R4
	BGT loop_2_end
	MOV R8, #0;R8每次取出数组中书的下标即内循环中的i，如果R8=R6则R7是质数，储存在数组中
loop_1;对应C++中的内循环
	CMP R8, R6
	BEQ loop_1_end
	MOV R0, R7
	
	LDR R2, =prime;R2是基准地址
	MOV R3, R8, LSL #2 ;R8左移2位，相当于R3=R8*4是地址偏移量，为什么左移2位？因为1个整型占4byte
	ADD R3, R2, R3; R3 就是数组元素prime[R8]的地址
	LDR R1, [R3]
	;这一段是用来读取数组中的数
	
	BL Is_Multi
	CMP R0, #1;判断是不是数组中的倍数，1为是，即该数不是质数
	BEQ loop_1_end
	ADD R8, R8, #1
	B loop_1
loop_1_end
	CMP R8, R6
	ADDEQ R5,R5,R7
	LDREQ R1, =prime
	MOVEQ R2, R6, LSL #2  ; 
	ADDEQ R1, R1, R2
	STREQ R7, [R1]
	;这一段用来在数组中存储一个数
	
	ADDEQ R6,R6, #1;数组个数+1
	ADD R7, R7, #1;i+1
	B loop_2
loop_2_end
	MOV R0, R5
	POP {R1-R12, PC}		
	ENDP

		
Is_Multi  PROC;判断R0是否为R1的倍数，是返回1，不是返回0
	PUSH {R2-R12, LR}
	MOV R2, R1
	MOV R3, R0
	MOV R0, #0 
loop
	CMP R3, R1
	BLT loop_end
	MOVEQ R0, #1
	BEQ loop_end				
	ADD R1, R1, R2
	B loop
loop_end
	POP {R2-R12, PC}				
	ENDP
	END

结果：