c语言内嵌arm汇编
如果你是想在一个文件里混写c语言和arm汇编，这个跟编译器有关系，如果你用gcc，可以用__asm__语法，请自行搜索__asm__相关资料
另一种方法，就是arm汇编文件和c语言文件分开来写，在c语言中声明函数符号即可。然后分别编译后再用链接器链到一起
Ⅱ c语言内嵌arm汇编，实现1+2+…+100
#include<stdio.h>
intmain(intargc,constchar*argv[])
{
intdata=0,result=0;
__asm__ __volatile__(
"movl$0,%[data] "
"movl$0,%0 "
"loop1:"
"inc%[data] "
"addl%[data],%0 "
"cmp$100,%[data] "
"jneloop1 "
:"=r"(result),[data]"=r"(data) /*Rotationresult.*/
:/*Rotatedvalue.*/
:/*Noclobbers*/
);
printf("result=%d,data=%d ",result,data);
return0;
}
gcc 的内联汇编 ， 执行效果:
$ gcc main.c -o main
$ ./main
result = 5050, data = 100
希望你满意！
Ⅲ arm编程，c语言中嵌入汇编实现1+2+3+...+100
C语言中static关键字的常见用法及举例
在嵌入式系统开发中，目前使用的主要编程语言是C和汇编，
C++已经有相应的编译器，但是现在使用还是比较少的。在稍大
规模的嵌入式软件中，例如含有OS，大部分的代码都是用C编
写的，主要是因为C语言的结构比较好，便于人的理解，而且有
大量的支持库。尽管如此，很多地方还是要用到汇编语言，例如
开机时硬件系统的初始化，包括CPU状态的设定，中断的使能，
主频的设定，以及RAM的控制参数及初始化，一些中断处理方
面也可能涉及汇编。另外一个使用汇编的地方就是一些对性能非
常敏感的代码块，这是不能依靠C编译器的生成代码，而要手工
编写汇编，达到优化的目的。而且，汇编语言是和CPU的指令集
紧密相连的，作为涉及底层的嵌入式系统开发，熟练对应汇编语
言的使用也是必须的。
单纯的C或者汇编编程请参考相关的书籍或者手册，这里主要讨
论C和汇编的混合编程，包括相互之间的函数调用。下面分四种
情况来进行讨论，暂不涉及C++。
1. 在C语言中内嵌汇编
在C中内嵌的汇编指令包含大部分的ARM和Thumb指令，不过其
使用与汇编文件中的指令有些不同，存在一些限制，主要有下面
几个方面：
a. 不能直接向PC寄存器赋值，程序跳转要使用B或者BL指令
b. 在使用物理寄存器时，不要使用过于复杂的C表达式，避免物理寄存器冲突
c.
R12和R13可能被编译器用来存放中间编译结果，计算表达式值时可能将R0到R3、R12及R14用于子程序调用，因此要避免直接使用这些物理寄存器
d. 一般不要直接指定物理寄存器，而让编译器进行分配
内嵌汇编使用的标记是 __asm或者asm关键字，用法如下：
__asm
{
instruction [; instruction]
…
[instruction]
}
asm(“instruction [; instruction]”);
下面通过一个例子来说明如何在C中内嵌汇编语言，
#include
void my_strcpy(const char *src, char *dest)
{
char ch;
__asm
{
loop:
ldrb ch, [src], #1
strb ch, [dest], #1
cmp ch, #0
bne loop
}
}
int main()
{
char *a = "forget it and move on!";
char b[64];
my_strcpy(a, b);
printf("original: %s", a);
printf("ed: %s", b);
return 0;
}
在这里C和汇编之间的值传递是用C的指针来实现的，因为指针
对应的是地址，所以汇编中也可以访问。
2. 在汇编中使用C定义的全局变量
内嵌汇编不用单独编辑汇编语言文件，比较简洁，但是有诸多限
制，当汇编的代码较多时一般放在单独的汇编文件中。这时就需
要在汇编和C之间进行一些数据的传递，最简便的办法就是使用
全局变量。
/* cfile.c
* 定义全局变量，并作为主调程序
*/
#include
int gVar_1 = 12;
extern asmDouble(void);
int main()
{
printf("original value of gVar_1 is: %d", gVar_1);
asmDouble();
printf(" modified value of gVar_1 is: %d", gVar_1);
return 0;
}
对应的汇编语言文件
;called by main(in C),to double an integer, a global var defined in C
is used.
AREA asmfile, CODE, READONLY
EXPORT asmDouble
IMPORT gVar_1
asmDouble
ldr r0, =gVar_1
ldr r1, [r0]
mov r2, #2
mul r3, r1, r2
str r3, [r0]
mov pc, lr
END
3. 在C中调用汇编的函数
在C中调用汇编文件中的函数，要做的主要工作有两个，一是在
C中声明函数原型，并加extern关键字;二是在汇编中用
EXPORT导出函数名，并用该函数名作为汇编代码段的标识，最
后用mov pc, lr返回。然后，就可以在C中使用该函数了。从
C的角度，并不知道该函数的实现是用C还是汇编。更深的原因
是因为C的函数名起到表明函数代码起始地址的左右，这个和汇
编的label是一致的。
/* cfile.c
* in C,call an asm function, asm_strcpy
* Sep 9, 2004
*/
#include
extern void asm_strcpy(const char *src, char *dest);
int main()
{
const char *s = "seasons in the sun";
char d[32];
asm_strcpy(s, d);
printf("source: %s", s);
printf(" destination: %s",d);
return 0;
}
;asm function implementation
AREA asmfile, CODE, READONLY
EXPORT asm_strcpy
asm_strcpy
loop
ldrb r4, [r0], #1 ;address increment after read
cmp r4, #0
beq over
strb r4, [r1], #1
b loop
over
mov pc, lr
END
在这里，C和汇编之间的参数传递是通过ATPCS(ARM
Thumb Procere Call Standard)的规定来进行的。简单的说就
是如果函数有不多于四个参数，对应的用R0-R3来进行传递，多
于4个时借助栈，函数的返回值通过R0来返回。
4. 在汇编中调用C的函数
在汇编中调用C的函数，需要在汇编中IMPORT 对应的C函数名
，然后将C的代码放在一个独立的C文件中进行编译，剩下的工
作由连接器来处理。
;the details of parameters transfer comes from ATPCS
;if there are more than 4 args, stack will be used
EXPORT asmfile
AREA asmfile, CODE, READONLY
IMPORT cFun
ENTRY
mov r0, #11
mov r1, #22
mov r2, #33
BL cFun
END
/*C file, called by asmfile */
int cFun(int a, int b, int c)
{
return a + b + c;
}
在汇编中调用C的函数，参数的传递也是通过ATPCS来实现
的。需要指出的是当函数的参数个数大于4时，要借助stack，具
体见ATPCS规范
Ⅳ arm中c语言嵌套汇编中:"=&r"(a)什么意思，=有时候就可以换成+实在不懂啊
p=&r跟*p=r区别&r是取变量r的地址,p=&r的意思是把变量r的地址赋给变量p,这种情况p一般是个指针。*p在等号左边,表示对p指向的内存空间赋值
Ⅳ 求一汇编小程序！用ARM汇编语言完成一个C语言嵌入式汇编方式实现字符串（数组）拷贝的功能
#include< reg51.h>
#include< stdio.h>
#include< string.h>
#define INBUF_LEN 4 //数据长度
unsigned char inbuf1[INBUF_LEN];
unsigned char checksum,count3 , flag,temp,ch;
bit read_flag=0;
sbit cp=P1^1;
sbit DIR=P1^2;
int i;
unsigned int xdata *RAMDATA; /*定义RAM地址指针*/
unsigned char a[6] ={0x11,0x22,0x33,0x44,0x55,0x66} ;
void init_serialcomm(void)
{
SCON=0x50; //在11.0592MHz下，设置串行口波特率为9600，方式1,并允许接收
PCON=0x00;
ES=1;
TMOD=0x21; //定时器工作于方式2，自动装载方式
TH0=(65536-1000)%256;
TL0=(65536-1000)/256;
TL1=0xfd;
TH1=0xfd;
ET0=1;
TR0=1;
TR1=1;
// TI=0;
EA=1;
// TI=1;
RAMDATA=0x1F45;
}
void serial () interrupt 4 using 3
{
if(RI)
{ RI=0;
ch=SBUF;
TI=1; //置SBUF空
switch(ch)
{
case 0x01 :printf("A"); TI=0;break;
case 0x02 :printf("B"); TI=0;break;
case 0x03 :printf("C"); TI=0;break;
case 0x04 :printf("D"); TI=0;break;
default :printf("fg"); TI=0;break;
}
}
}
//向串口发送一个字符
void timer0() interrupt 1 using 3{
// char i;
flag++;
TH0=0x00;
TL0=0x00;
if(flag==10)
{// cp=!cp;
// for(i=0;i<6;i++)
P2=0x25;
TI=1;
temp=*RAMDATA;
printf("%c",temp);
TI=0;
// RAMDATA--;
flag=0;
}
}
//主程序
main()
{
init_serialcomm(); //初始化串口
//向6264中送数据
{
*RAMDATA=0x33;
}
while(1)
{
*RAMDATA=0x33;;
}
}
Ⅵ 如何在C或C++代码中嵌入ARM汇编代码
C语言中嵌入汇编的方法是加入关键字“asm”来实现的，如： 例1： main（） { asm mov ah,2; asm mov bh,0; asm mov dl, 20; asm mov dh,10; asm int 10h; } 例2： main（） { asm{ mov ah,2; mov bh,0; mov dl, 20; mov dh,10; int 10h; } }
Ⅶ arm，c语言中嵌入ARM汇编，实现1+2+3+...+100
实在不会的话，先用C写出来，然后再汇编调试界面看看汇编代码，不是很难。
Ⅷ 如何在C语言中嵌入汇编
以下所说嵌入的汇编都是GUN 的C语言中嵌入ARM汇编。
1）2个参数的内嵌语句
这种形式的汇编用于简单的语句，参数限制输入和输出语法格式如下：
asm(code : output operand list : inputoperand list : clobber list);
汇编和C语句这间的联系是通过上面asm声明中可选的output operand list和input operand list。Clobber list后面再讲。
下面是将C语言的一个整型变量传递给汇编，逻辑左移一位后在传递给C语言的另外一个整型变量。
/* Rotating bits example */
asm("mov %[result], %[value], ror#1" : [result] "=r" (y) : [value] "r" (x));
每一个asm语句被冒号（:）分成了四个部分。
汇编指令放在第一部分中的“”中间。
"mov %[result], %[value], ror #1"
接下来是冒号后的可选择的output operand list，每一个条目是由一对[]（方括号）和被他包括的符号名组成，它后面跟着限制性字符串，再后面是圆括号和它括着的C变量。这个例子中只有一个条目。
[result] "=r" (y)
接着冒号后面是输入操作符列表，它的语法和输入操作列表一样
[value] "r" (x)
为了增加代码的可读性，你可以使用换行，空格，还有C风格的注释。
asm("mov %[result], %[value], ror#1"
: [result]"=r" (y) /* Rotation result. */
: [value]"r" (x) /* Rotated value. */
: /* No clobbers */
);
在代码部分%后面跟着的是后面两个部分方括号中的符号，它指的是相同符号操作列表中的一个条目。
%[result]表示第二部分的C变量y，%[value]表示三部分的C变量x；
符号操作符的名字使用了独立的命名空间。这就意味着它使用的是其他的符号表。简单一点就是说你不必关心使用的符号名在C代码中已经使用了。在早期的C代码中，循环移位的例子必须要这么写：
asm("mov %0, %1, ror #1" :"=r" (result) : "r" (value))
在汇编代码中操作数的引用使用的是%后面跟一个数字，%1代表第一个操作数，%2代码第二个操作数，往后的类推。这个方法目前最新的编译器还是支持的。但是它不便于维护代码
实例代码：
2) 带.s文件的汇编
编译命令：
arm-linux-gcc main.cAsmfile_gnu.s -o mains
main.c
#include<stdio.h>
extern voidpcm8_2_pcm16(unsigned char* pIn, int nInlen, short* pOut);
extern voidpcm16_2_pcm8(short* pIn, int nInlen,unsigned char* pOut);
int main()
{
unsigned char* pIn="1234";
short pInd[256];
unsigned char pOutd[256];
int nInlen=4;
int i = 0;
short pOut[256];
for(i=0;i<4;i++)
printf(" 0x%x ",pIn[i]);
printf(" ");
memset((char *)pOut,0,256*2);
memset((char *)pInd,0,256*2);
memset((char *)pOutd,0,256*2);
pcm8_2_pcm16(pIn,nInlen,pOut);
for(i=0;i<4;i++)
printf(" 0x%x ",pOut[i]);
printf(" ");
memcpy((char *)pInd,(char *)pOut,256*2);
pcm16_2_pcm8(pInd,nInlen,pOutd);
for(i=0;i<4;i++)
printf(" 0x%x ",pOutd[i]);
printf(" ");
return 0;
}
Asmfile_gnu.s
.text
.global pcm8_2_pcm16
.global pcm16_2_pcm8
#*******************************#
#********* ENCODER 实现将第一个输入参数
#左移8位然后异或0x8000 然后拷贝到第三个参数
#DECODE 取第一个参数所指的数据先异或0x8000
#然后右移8位将数据拷贝到第三个参数
#*******************************
pcm8_2_pcm16:
MOV R6,#0
MOV R7,#0
ENCODER:
LDRB R5,[R0,R6]
MOV R8,R5,LSL#8
EOR R9,R8,#0x8000
STRH R9,[R2,R7]
ADD R7,R7,#2
ADD R6,R6,#1
SUB R1,R1,#1
CMP R1,#0
BNE ENCODER
B OVER
pcm16_2_pcm8:
MOV R6,#0
MOV R7,#0
DECODE:
LDRH R5,[R0,R6]
EOR R8,R5,#0x8000
MOV R9,R8,LSR#8
STRB R9,[R2,R7]
ADD R7,R7,#1
ADD R6,R6,#2
SUB R1,R1,#1
CMP R1,#0
BNE DECODE
OVER:
.end
Ⅸ arm汇编里面，对这处理器的操作可以用c语言吗比方说这条指令 mcr p15，0, r4,c2,
不可以，这是协处理器指令，不能用c语言只能用汇编