arm汇编语言调用C函数之参数传递
arm汇编语言调用C函数之参数传递
于ARM体系来说，不同语言撰写的函数之间相互调用（mix calls）遵循的是 ATPCS（ARM-Thumb Procedure Call Standard），ATPCS 主要是定义了函数呼叫时参数的传递规则以及如何从函数返回，关于ATPCS的详细内容可以查看ADS1.2 Online Books ——Developer Guide的2.1节。这篇文档要讲的是汇编代码中对C函数调用时如何进行参数的传递以及如何从C函数正确返回。
不同于x86的参数传递规则，ATPCS建议函数的形参不超过4个，如果形参个数少于或等于4，则形参由R0,R1,R2,R3四个寄存器进行传递；若形参个数大于4，大于4的部分必须通过堆栈进行传递。
我们先讨论一下形参个数为4的情况.
实例1：
test_asm_args.asm
//--------------------------------------------------------------------------------
IMPORT test_c_args ;声明test_c_args函数
AREA TEST_ASM, CODE, READONLY
EXPORT test_asm_args
test_asm_args
STR lr, [sp, #-4]! ;保存当前lr
ldr r0,=0x10 ;参数 1
ldr r1,=0x20 ;参数 2
ldr r2,=0x30 ;参数 3
ldr r3,=0x40 ;参数 4
bl test_c_args ;调用C函数
LDR pc, [sp], #4 ;将lr装进pc(返回main函数)
END
test_c_args.c
//--------------------------------------------------------------------------------
void test_c_args(int a,int b,int c,int d)
{
printk("test_c_args:\n");
printk("%0x %0x %0x %0x\n",a,b,c,d);
}
main.c
//--------------------------------------------------------------------------------
int main()
{
test_asm_args();
for(;;);
}
程序从main函数开始执行,main调用了test_asm_args,test_asm_args 调用了test_c_args,最后从test_asm_args返回main。代码分别使用了
汇编和C定义了两个函数,test_asm_args 和 test_c_args,test_asm_args
调用了test_c_args,其参数的传递方式就是向R0~R3分别写入参数值，之后使用bl语句对test_c_args进行调用。其中值得注意的地方是用红色标记的语句，test_asm_args在调用test_c_args之前必须把当前
的 lr入栈，调用完test_c_args之后再把刚才保存在栈中的lr写回pc,这样才能返回到main函数中。
如果test_c_args的参数是8个呢？这种情况test_asm_args应该怎样传递参数呢？
实例2：
test_asm_args.asm
//--------------------------------------------------------------------------------
IMPORT test_c_args ;声明test_c_args函数
AREA TEST_ASM, CODE, READONLY
EXPORT test_asm_args
test_asm_args
STR lr, [sp, #-4]! ;保存当前lr
ldr r0,=0x1 ;参数 1
ldr r1,=0x2 ;参数 2
ldr r2,=0x3 ;参数 3
ldr r3,=0x4 ;参数 4
ldr r4,=0x8
str r4,[sp,#-4]! ;参数 8 入栈
ldr r4,=0x7
str r4,[sp,#-4]! ;参数 7 入栈
ldr r4,=0x6
str r4,[sp,#-4]! ;参数 6 入栈
ldr r4,=0x5
str r4,[sp,#-4]! ;参数 5 入栈
bl test_c_args_lots
ADD sp, sp, #4 ;清除栈中参数 5,本语句执行完后sp指向参数6 ADD sp, sp, #4 ;清除栈中参数 6,本语句执行完后sp指向参数7 ADD sp, sp, #4 ;清除栈中参数 7,本语句执行完后sp指向参数8 ADD sp, sp, #4 ;清除栈中参数 8,本语句执行完后sp指向 lr
LDR pc, [sp],#4 ;将lr装进pc(返回main函数)
END
test_c_args.c
//--------------------------------------------------------------------------------void test_c_args(int a,int b,int c,int d,int e,int f,int g,int h)
{
printk("test_c_args_lots:\n");
printk("%0x %0x %0x %0x %0x %0x %0x %0x\n",
a,b,c,d,e,f,g,h);
}
main.c
//--------------------------------------------------------------------------------
int main()
{
test_asm_args();
for(;;);
}
这部分的代码和实例1的代码大部分是相同的，不同的地方是
test_c_args的参数个数和test_asm_args的参数传递方式。
在test_asm_args中，参数1～参数4还是通过R0~R3进行传递，而参数5～参数8则是通过把其压入堆栈的方式进行传递，不过要注意这四个入栈参数的入栈顺序，是以参数8->参数7->参数6->参数5的顺序入栈的。
直到调用test_c_args之前，堆栈内容如下：
sp->+----------+
| 参数5 |
+----------+
| 参数6 |
+----------+
| 参数7 |
+----------+
| 参数8 |
+----------+
| lr |
+----------+
test_c_args执行返回后，则设置sp,对之前入栈的参数进行清除，最后将lr装入pc返回main函数，在执行 LDR pc, [sp],#4 指令之前堆栈内容如下：
+----------+
| 参数5 |
+----------+
| 参数6 |
+----------+
| 参数7 |
+----------+
| 参数8 |
sp->+----------+
| lr |
+----------+
基于ARM的C语言与汇编语言混合编程
1、C语言与汇编语言混合编程应遵守的规则
ARM编程中使用的C语言是标准C语言，ARM的开发环境实际上就是嵌入了一个C语言的集成开发环境，只不过这个开发环境与ARM的硬件紧密相关。
在使用C语言时，要用到和汇编语言的混合编程。若汇编代码较为简洁，则可使用直接内嵌汇编的方法；否则要将汇编程序以文件的形式加入到项目中，按照ATPCS(ARM/Thumb过程调用标准，
ARM/Thumb Procedure Call Standard)的规定与C程序相互调用与访问。
在C程序和ARM汇编程序之间相互调用时必须遵守ATPCS规则。ATPCS规定了一些子程序间调用的基本规则，哪寄存器的使用规则，堆栈的使用规则和参数的传递规则等。
1)寄存器的使用规则
子程序之间通过寄存器r0~r3来传递参数，当参数个数多于4个时，使用堆栈来传递参数。此时r0~r3可记作A1~A4。
在子程序中，使用寄存器r4~r11保存局部变量。因此当进行子程序调用时要注意对这些寄存器的保存和恢复。此时r4~r11可记作
V1~V8。
寄存器r12用于保存堆栈指针SP，当子程序返回时使用该寄存器出栈，记作IP。
寄存器r13用作堆栈指针，记作SP。寄存器r14称为链接寄存器，记作LR。该寄存器用于保存子程序的返回地址。
寄存器r15称为程序计数器，记作PC。
2)堆栈的使用规则
ATPCS规定堆栈采用满递减类型(FD,Full Descending)，即堆栈通过减小存储器地址而向下增长，堆栈指针指向内含有效数据项的最低地址。
3)参数的传递规则
整数参数的前4个使用r0~r3传递，其他参数使用堆栈传递；浮点参数使用编号最小且能够满足需要的一组连续的FP寄存器传递参数。子程序的返回结果为一个32位整数时，通过r0返回；返回结果为一个64位整数时，通过r0和r1返回；依此类推。结果为浮点数时，通过浮点运算部件的寄存器F0、D0或者S0返回。
2、汇编程序调用C程序的方法
汇编程序的书写要遵循ATPCS规则，以保证程序调用时参数正确传递。在汇编程序中调用C程序的方法为：首先在汇编程序中使用IMPORT伪指令事先声明将要调用的C语言函数；然后通过BL指令来调用C函数。
例如在一个C源文件中定义了如下求和函数：
int add(int x,int y){
return(x+y);
}
调用add()函数的汇编程序结构如下：
IMPORT add ;声明要调用的C函数
……
MOV r0,1
MOV r1,2
BL add ;调用C函数add
……
当进行函数调用时，使用r0和r1实现参数传递，返回结果由r0带回。函数调用结束后，r0的值变成3。
3、C程序调用汇编程序的方法
C程序调用汇编程序时，汇编程序的书写也要遵循ATPCS规则，以保证程序调用时参数正确传递。在C程序中调用汇编子程序的方法为：首先在汇编程序中使用EXPORT伪指令声明被调用的子程序，表示该子程序将在其他文件中被调用；然后在C程序中使用extern
关键字声明要调用的汇编子程序为外部函数。
例如在一个汇编源文件中定义了如下求和函数：
EXPORT add ;声明add子程序将被外部函数调用
……
add ;求和子程序add
ADD r0,r0,r1
MOV pc,lr
……
在一个C程序的main()函数中对add汇编子程序进行了调用：extern int add (int x,int y); //声明add为外部函数
void main(){
int a=1,b=2,c;
c=add(a,b); //调用add子程序
……
}
当main()函数调用add汇编子程序时，变量a、b的值会给了r0和r1，返回结果由r0带回，并赋值给变量c。函数调用结束后，变量c的值变成3。
4、C程序中内嵌汇编语句
在C语言中内嵌汇编语句可以实现一些高级语言不能实现或者不容易实现的功能。对于时间紧迫的功能也可以通过在C语言中内嵌汇编语句来实现。内嵌的汇编器支持大部分ARM指令和Thumb指令，但是不支持诸如直接修改PC实现跳转的底层功能，也不能直接引用C语言中的变量。
嵌入式汇编语句在形式上独立定义的函数体，其语法格式为：
__asm
{
指令[;指令]
……
[指令]
}
其中“__asm”为内嵌汇编语句的关键字，需要特别注意的是前面有两个下划线。指令之间用分号分隔，如果一条指令占据多行，除最后一行外都要使用连字符“\”。
5、基于ARM的C语言与汇编语言混合编程举例
下面给出了一个向串口不断发送0x55的例子：
该工程的启动代码使用汇编语言编写，向串口发送数据使用C语言实现，下面是启动代码的整体框架：
……
IMPORT Main
AREA Init,CODE,READONLY;
ENTRY
……
BL Main ;跳转到Main()函数处的C/C++程序
……
END ;标识汇编程序结束
下面是使用C语言编写的主函数：
#include "..\inc\config.h" //将有关硬件定义的头文件包含进来unsigned char data; //定义全局变量
void main(void){
Target_Init(); //对目标板的硬件初始化
Delay(10); //延时
data=0x55; //给全局变量赋值
while(1) {
Uart_Printf("%x",data); //向串口送数Delay(10);
}
}
参数传递方式
引用在函数参数传递中的作用 传递参数有三种方法：1，传递对象本身。2，传递指向对象的指针。3，传递对象的引用。 (1)传值方式 ①传给被调用函数的是整型、长整型、浮点型或双精度型变量。被调用的函数得定义相应的变量为形参。 ②传给被调用函数的是结构变量。被调用函数得定义结构变量为形参。 ③传给被调用函数的是结构变量的成员。被调用函数得定义与该成员同类的变量为形参。 #include "stdio.h" ?#include
#include "stdio.h" void swapint(); int a,b; void main() { a = 5, b = 10; swapint(); printf("%d\n%d\n",a,b); } void swapint() { int temp; temp=a; a=b; b=temp; } （2）传址方式 ①传给被调用函数的是变量的地址。被调用函数得定义指针变量为形参。 ②传给被调用函数的是数组的地址即数组名。被调用的函数得定义数组或指针变量为形参。 ③传给被调用函数的是函数的地址即函数名称。被调用函数得定义指向函
数的指针变量为形参。④传给被调用函数的是结构的地址。被调用函数得定义结构指针为形参。 #include "stdio.h" ?#include
C语言与汇编语言互相调用
浅谈C程序中调用汇编模块的方法 C语言是目前非常流行的一种编程语言，除具有高级语言使用方便灵活、数据处理能力强、编程简单等优点外，还可实现汇编语言的大部分功能，如可直接对硬件进行操作、生成的目标代码质量较高且执行的速度较快等。所以在工程上对硬件处理速度要求不很高的情况下，基本可以用C代替汇编语言，编写接口电路的控制软件。但C也不能完全取代汇编语言，如在一些对速度要求很高的实时控制系统中，以及对硬件的特殊控制方面，C有时也不能完全很好胜任，还需要汇编语言来编写。因为汇编语言目标代码更精练，对硬件直接控制能力更强和执行速度更快，但汇编语言编程烦难、表达能力差也显而易见。比较好的解决办法是C与汇编语言混合编程，即用C编写软件的调度程序、用户界面以及速度要求不高的控制部分，而用汇编语言对速度敏感部分提供最高速度的处理模块，供C调用。这种方法提供了最佳的软件设计方案，做到了兼顾速度效率高和灵活方便。由于本人的毕业设计需要C 程序中调用汇编模块的方法来提高ARM定点指令的执行速度，故对这方面进行了学习。学习心得如下： 对于C和汇编语言的接口主要有两个问题需要解决。 一、调用者与被调用者的参数传递 这种数据传递通过堆栈完成，在执行调用时从调用程序参数表中的最后一个参数开始，自动依次压入堆栈；将所有参数压入堆栈后，再自动将被调用程序执行结束后的返回地址（断点）压入堆栈，以使被调程序结束后能返回主调程序的正确位置而继续执行。例如一调用名为add汇编程序模块的主函数：main( ){...... add(dest,op1,op2,flages)；......}。在此例中对主函数进行反汇编，主函数在调用add函数前自动组织的堆栈。 . . . lea 0xfffffffe8(%ebp),%eax #flages数组的首地址入栈 push %eax pushl 0xfffffff8(%ebp) #OP2入栈 pushl 0xfffffffc(%ebp) #OP1 入栈 pushl 0xfffffff0(%ebp) #dest地址入栈 call 0x80483f0
C++中函数调用时的三种参数传递方式
在C++中，参数传递的方式是“实虚结合”。 ?按值传递(pass by value) ?地址传递(pass by pointer) ?引用传递(pass by reference) 按值传递的过程为：首先计算出实参表达式的值，接着给对应的形参变量分配一个存储空间，该空间的大小等于该形参类型的，然后把以求出的实参表达式的值一一存入到形参变量分配的存储空间中，成为形参变量的初值，供被调用函数执行时使用。这种传递是把实参表达式的值传送给对应的形参变量，故称这种传递方式为“按值传递”。 使用这种方式，调用函数本省不对实参进行操作，也就是说，即使形参的值在函数中发生了变化，实参的值也完全不会受到影响，仍为调用前的值。 [cpp]view plaincopy 1./* 2. pass By value 3.*/ 4.#include
如果在函数定义时将形参说明成指针，对这样的函数进行调用时就需要指定地址值形式的实参。这时的参数传递方式就是地址传递方式。 地址传递与按值传递的不同在于，它把实参的存储地址传送给对应的形参，从而使得形参指针和实参指针指向同一个地址。因此，被调用函数中对形参指针所指向的地址中内容的任何改变都会影响到实参。 [cpp]view plaincopy 1.#include
C#中方法的参数有四种类型
C#中方法的参数有四种类型 1. 值参数(不加任何修饰符,是默认的类型) 2. 引用型参数(以ref 修饰符声明) 3. 输出参数(以out 修饰符声明) 4. 数组型参数(以params 修饰符声明) 1. 值传递: 值类型是方法默认的参数类型，采用的是值拷贝的方式。也就是说，如果使用的是值类型，则可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值。 使用值类型的例子如：（下面的Swap()未能实现交换的功能，因为控制传递回调用方时不保留更改的值） using System; class Test { static void Swap(int x, int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(i, j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 输出结果为: i=1, j=2 * 未能实现Swap()计划的功能 */ 2. 引用传递(ref类型) ref关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。 2.1. 若要使用ref 参数，则方法定义和调用方法都必须显式使用ref关键字。 2.2. 传递到ref 参数的参数必须最先初始化。这与out 不同，out 的参数在传递之前不需要显式初始化。 2.3. 如果一个方法采用ref 或out 参数，而另一个方法不采用这两类参数，则可以进行重载。
相关实例如下: using System; class Test { static void Swap(ref int x, ref int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(ref i, ref j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 引用类型实现了Swap()计划的功能: * 输出为: * i = 2, j =1 */ 3. 输出类型(out类型) out 关键字会导致参数通过引用来传递。这与ref 关键字类似。 与ref 的不同之处： 3.1. ref 要求变量必须在传递之前进行初始化，out 参数传递的变量不需要在传递之前进行初始化。 3.2. 尽管作为out 参数传递的变量不需要在传递之前进行初始化，但需要在调用方法初始化以便在方法返回之前赋值。 示例如下: using System; class Test { static void Swap(out int x, out int y) { //在这里进行了i和j的初始化
函数参数传递的原理
函数参数传递的原理 参数传递，是在程序运行过程中，实际参数就会将参数值传递给相应的形式参数，然后在函数中实现对数据处理和返回的过程，方法有按值传递参数，按地址传递参数和按数组传递参数。 形参：指出现在Sub 和Function过程形参表中的变量名、数组名，该过程在被调用前，没有为它们分配内存，其作用是说明自变量的类型和形态以及在过程中的作用。形参可以是除定长字符串变量之外的合法变量名，也可以带括号的数组名。 实参：实参就是在调用Sub 和Function过程时，从主调过程传递给被调用过程的参数值。实参可以是变量名、数组名、常数或表达式。在过程调用传递参数时，形参与实参是按位置结合的，形参表和实参表中对应的变量名可以不必相同，但它们的数据类型、参数个数及位置必须一一对应。 等号、函数名称、括弧和参数，是函数的四个组成部分。 函数“=SUM（1，2，3）”，1、2和3就是SUM函数的参数，没有参数1、2、3，函数SUM 则无从求值。 函数“=VLOOKUP（2，A:C，3，）”，没有参数2、A:C和3，函数VLOOKUP如何在A:C 区域查找A列中是2那一行第3列的数值？ 当然，也有不需要参数的函数，如“=PI（）”、“=NOW（）”、“TODAY（）”等。 函数参数传递的原理C语言中参数的传递方式一般存在两种方式：一种是通过栈的形式传递，另一种是通过寄存器的方式传递的。这次，我们只是详细描述一下第一种参数传递方式，另外一种方式在这里不做详细介绍。 首先，我们看一下，下面一个简单的调用例程： int Add （int a，int b，int c） { return a+b+c; }
汇编语言的过程调用与c语言的函数调用
姓名：孙贵森 学号： 汇编语言地过程调用，如果需要传递参数，一般有种方法，通过寄存器来“传递”，或是通过参数来传递.（还有将所有参数制成参数列表并压栈地传递方法，但较少用.)通过寄存器来“传递”，不是真正意义上地传递，其只不过是事先在几个有限地寄存器中设置相应地值后，再调用过程，过程再直接读取这些寄存器地内容.可想而知，此法犹如语言中地全局变量，极易感染.而如果通过参数来传递，又不得不面临手工维护堆栈框架( )地重担.堆栈框架动态地存放着参数、调用过程地返回地址、过程局部变量、过程内地压栈等内容，也是不好对付地.一般情况下，一个普通地过程可能如下编写：文档来自于网络搜索 , ..... 作为遵从调用约定（）调用者，则需这样调用上述过程： ; ; ; , * ; 而如果遵从调用约定，则： , ...... , [ ] ; , [ ]; ...... * ; , , ; ...... , [ ]; , [ ]; , [ ; , [ ]; ...... , ; * ;
在被调用地过程内，分为种情况： . 无参数，也无局部变量 . 有参数 . 有局部变量 当无参数且无局部变量时，堆栈中只是保存语句地下一条语句地地址，可以很安全地返回.而当有参数，使用伪指令地接收参数地形式，则会自动生成正确地返回代码.而当有局部变量，使用伪指令来定义局部变量，也会自动地生成正确地返回代码.在将参数压栈时，仍需将其打包为位地，文档来自于网络搜索 ; , ; ; 另一选择是，将用作地变量声明为. ; ; 还有另一种方法，即，总是传递指针. ; (, ) , ; , , , , , [] , , [] 这种方法在保留了我们可以声明仅需地变量类型地同时，也确保位地方法正确压栈.语言中地每一个函数都是一个独立地代码块.一个函数地代码块是隐藏于函数内部地，不能被任何其它函数中地任何语句（除调用它地语句之外）所访问（例如，用语句跳转到另一个函数内部是不可能地）.构成一个函数体地代码对程序地其它部分来说是隐蔽地，它既不能影响程序其它部分，也不受其它部分地影响.换言之，由于两个函数有不同地作用域，定义在
函数调用参数传递类型(java)的用法介绍.
函数调用参数传递类型（java）的用法介绍. java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ;
TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 {
汇编语言编程规范
软件设计更多地是一种工程，而不是一种个人艺术。如果不统一编程规范，最终写出的程序，其可读性将较差，这不仅给代码的理解带来障碍，增加维护阶段的工作量，同时不规范的代码隐含错误的可能性也比较大。 分析表明，编码阶段产生的错误当中，语法错误大概占20%左右，而由于未严格检查软件逻辑导致的错误、函数（模块）之间接口错误及由于代码可理解度低导致优化维护阶段对代码的错误修改引起的错误则占了一半以上。 可见，提高软件质量必须降低编码阶段的错误率。如何有效降低编码阶段的错误呢？这需要制定详细的软件编程规范，并培训每一位程序员，最终的结果可以把编码阶段的错误降至10%左右，同时也降低了程序的测试费用，效果相当显著。 本文从代码的可维护性（可读性、可理解性、可修改性）、代码逻辑与效率、函数（模块）接口、可测试性四个方面阐述了软件编程规范，规范分成规则和建议两种，其中规则部分为强制执行项目，而建议部分则不作强制，可根据习惯取舍。 1．排版 规则1 程序块使用缩进方式，函数和标号使用空格缩进，程序段混合使用TAB和空格缩进。缩进的目的是使程序结构清晰，便于阅读和理解。
MOVX A, @DPTR MOV SBUF, A JNB TI, $ CLR TI INC DPTR CJNE R1, #20H, read1kpage INC R2 MOV R1, #00H CPL WDI CJNE R2, #20H, read1kloop ;END OF EEPROM 规则2 在指令的操作数之间的，使用空格进行间隔，采用这种松散方式编写代码的目的是使代码更加清晰。 例如： CJNE R2, #20H, read1kloop ;END OF EEPROM 规则3 一行最多写一条语句。 规则4 变量定义时，保持对齐。便于阅读和检查内存的使用情况。 例如： RegLEDLOSS EQU 30H ; VARIABLE ; TESTLED==RegLEDLOSS.0 RegLEDRA EQU 31H ; VARIABLE
arm汇编语言调用C函数之参数传递
arm汇编语言调用C函数之参数传递 于ARM体系来说，不同语言撰写的函数之间相互调用（mix calls）遵循的是 ATPCS（ARM-Thumb Procedure Call Standard），ATPCS 主要是定义了函数呼叫时参数的传递规则以及如何从函数返回，关于ATPCS的详细内容可以查看ADS1.2 Online Books ——Developer Guide的2.1节。这篇文档要讲的是汇编代码中对C函数调用时如何进行参数的传递以及如何从C函数正确返回。 不同于x86的参数传递规则，ATPCS建议函数的形参不超过4个，如果形参个数少于或等于4，则形参由R0,R1,R2,R3四个寄存器进行传递；若形参个数大于4，大于4的部分必须通过堆栈进行传递。 我们先讨论一下形参个数为4的情况. 实例1： test_asm_args.asm //-------------------------------------------------------------------------------- IMPORT test_c_args ;声明test_c_args函数 AREA TEST_ASM, CODE, READONLY EXPORT test_asm_args test_asm_args STR lr, [sp, #-4]! ;保存当前lr ldr r0,=0x10 ;参数 1 ldr r1,=0x20 ;参数 2
ldr r2,=0x30 ;参数 3 ldr r3,=0x40 ;参数 4 bl test_c_args ;调用C函数 LDR pc, [sp], #4 ;将lr装进pc(返回main函数) END test_c_args.c //-------------------------------------------------------------------------------- void test_c_args(int a,int b,int c,int d) { printk("test_c_args:\n"); printk("%0x %0x %0x %0x\n",a,b,c,d); } main.c //-------------------------------------------------------------------------------- int main() { test_asm_args(); for(;;); } 程序从main函数开始执行,main调用了test_asm_args,test_asm_args 调用了test_c_args,最后从test_asm_args返回main。代码分别使用了
总结Java方法(函数)传值和传引用的问题
总结Java方法(函数)传值和传引用的问题 java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ;
TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 {
C语言函数参数传递(非常重要)
一、三道考题 开讲之前，我先请你做三道题目。（嘿嘿，得先把你的头脑搞昏才行……唉呀，谁扔我鸡蛋？） 考题一，程序代码如下： void Exchg1(int x, int y) { int tmp; tmp = x; x = y; y = tmp; printf("x = %d, y = %d\n", x, y); } main() { int a = 4,b = 6; Exchg1(a, b); printf("a = %d, b = %d\n", a, b); return(0); } 输出的结果为： x = ____, y=____. a = ____, b=____. 问下划线的部分应是什么，请完成。 考题二，程序代码如下： void Exchg2(int *px, int *py) { int tmp = *px; *px = *py; *py = tmp; printf("*px = %d, *py = %d.\n", *px, *py); } main() { int a = 4; int b = 6; Exchg2(&a, &b); printf("a = %d, b = %d.\n", a, b); return(0); } 输出的结果为为： *px=____, *py=____.
a=____, b=____. 问下划线的部分应是什么，请完成。 考题三，程序代码如下： void Exchg3(int &x, int &y) { int tmp = x; x = y; y = tmp; printf("x = %d,y = %d\n", x, y); } main() { int a = 4; int b = 6; Exchg3(a, b); printf("a = %d, b = %d\n", a, b); return(0); } 输出的结果为： x=____, y=____. a=____, b=____. 问下划线的部分应是什么，请完成。你不在机子上试，能作出来吗？你对你写出的答案有多大的把握？正确的答案，想知道吗？（呵呵，让我慢慢地告诉你吧！） 好，废话少说，继续我们的探索之旅了。 我们都知道：C语言中函数参数的传递有：值传递、地址传递、引用传递这三种形式。题一为值传递，题二为地址传递，题三为引用传递。不过，正是这几种参数传递的形式，曾把我给搞得晕头转向。我相信也有很多人与我有同感吧？ 下面请让我逐个地谈谈这三种传递形式。 二、函数参数传递方式之一：值传递 （1）值传递的一个错误认识 先看考题一中Exchg1函数的定义： void Exchg1(int x, int y) /* 定义中的x,y变量被称为Exchg1函数的形式参数*/ { int tmp; tmp = x; x = y; y = tmp; printf("x = %d, y = %d.\n", x, y); }
c语言值传递的3种形式
//全部摘自别的博客，以前对值传递很迷糊，看完豁然开朗，整理下，来百度文库赚点分。 一、三道考题 开讲之前，我先请你做三道题目。（嘿嘿，得先把你的头脑搞昏才行……唉呀，谁扔我鸡蛋？） 考题一，程序代码如下： void Exchg1(int x, int y) { inttmp; tmp = x; x = y; y = tmp; printf("x = %d, y = %d\n", x, y); } main() { int a = 4,b = 6; Exchg1(a, b); printf("a = %d, b = %d\n", a, b); return(0); } 输出的结果为： x = ____, y=____. a = ____, b=____. 问下划线的部分应是什么，请完成。 考题二，程序代码如下： void Exchg2(int *px, int *py) { inttmp = *px; *px = *py; *py = tmp; printf("*px = %d, *py = %d.\n", *px, *py); } main() { int a = 4; int b = 6; Exchg2(&a, &b);
printf("a = %d, b = %d.\n", a, b); return(0); } 输出的结果为为： *px=____, *py=____. a=____, b=____. 问下划线的部分应是什么，请完成。 考题三，程序代码如下： void Exchg3(int&x, int&y) { inttmp = x; x = y; y = tmp; printf("x = %d,y = %d\n", x, y); } main() { int a = 4; int b = 6; Exchg3(a, b); printf("a = %d, b = %d\n", a, b); return(0); } 输出的结果为： x=____, y=____. a=____, b=____. 问下划线的部分应是什么，请完成。你不在机子上试，能作出来吗？你对你写出的答案有多大的把握？正确的答案，想知道吗？（呵呵，让我慢慢地告诉你吧！） 好，废话少说，继续我们的探索之旅了。 我们都知道：C语言中函数参数的传递有：值传递、地址传递、引用传递这三种形式。题一为值传递，题二为地址传递，题三为引用传递。不过，正是这几种参数传递的形式，曾把我给搞得晕头转向。我相信也有很多人与我有同感吧？ 下面请让我逐个地谈谈这三种传递形式。 二、函数参数传递方式之一：值传递 （1）值传递的一个错误认识 先看考题一中Exchg1函数的定义： void Exchg1(int x, int y) /* 定义中的x,y变量被称为Exchg1函数的形式参数*/ {
C语言中参数传递
二．参数传递 函数的形参的初始化和变量的初始化一样，如果形参具有非引用类型，则复制实参的值，如果形参为引用类型，则它是实参的别名。 1．非引用实参 普通的非引用类型的函数通过复制对应的实参实现初始化。当用实参副本初始化形参时，函数并没有调用所传递的实参本身，因此不会修改实参的值。 注解：非引用形参表示对应实参的局部副本，对这类行参的修改仅仅改变了局部副本的值，一旦函数执行结束，这些局部变量的值也就没有了。 a. 指针形参 指针形参与其他非引用类型的行参一样，如果将新指针赋给行参，主调函数使用的实参指针的值没有改变。事实上被复制的指针只影响对指针的赋值。指针形参是const类型还是非const类型，将影响函数调用所使用的实参。 b. const行参 在调用函数时，如果该函数使用非引用的非const形参，则既给该函数传递const实参也可传递非const的实参(因为改变形参不影响const的实参，所以const实参不会被改变)。如果将形参定义为非引用的const类型，则在函数中，不可以改变实参的局部副本，由于实参是以副本的形式传递，因此传递给函数形参既可是const也可是非const对象。 注意：尽管函数的形参是const，但是编译器却将该行参声明视为普通的int型。 void fcn(const int i); void fcn(int i); 为了兼顾C语言，认为这两种定义并不区别。 c. 复制实参的局限性 不适合复制实参的情况包括： 当需要在函数中修改实参的值时 当需要以大型对象作为实参传递时，对实际的应用而言，复制对象所付出的时间和存储空间代价往往很大。 但没有办法实习对象的复制时 对于以上几种情况，有效的办法是将形参定义为引用或指针。 2．引用实参 与所有引用一样，引用形参直接关联到其所绑定的对象，而并非这些对象的副本。定义引
深入了解C语言(函数的参数传递和函数使用参数的方法)
深入了解C语言(函数的参数传递和函数使用参数的方法) C语言生成的代码在执行效率上比其它高级语言都高.现在让我们来看看C语言生成的代码具体是什么样子的.当你看完本文对于C语言的了解一定会更深一步了. 本文通过一个个实际案例程序来讲解C语言. 研究案例一 工具: Turboc C v2.0,Debug,MASM v5.0,NASM 实例C程序: /* example1.c */ char ch; int e_main() { e_putchar(ch); } 目标内容:C语言调用函数的方法与细节 我们使用的C编译器是16位的Turboc C v2.0,它生成的是16位的代码,比较简单,方便我们来研究.同时我们也需要用到DOS下的DEBUG来进行反汇编.由于我们很多案例中的程序并不是完整的C程序,所以Turboc下的Tlink并不能为我们生成目标程序,所以我将使用MASM 中的link.exe,同时里面的https://www.wendangku.net/doc/9514589198.html,也可以为我们把exe文件转换成bin文件. 这个程序没有main函数,我们用e_main来代替main函数.这样我们能避开C语言对main函数进行一系列处理的代码.同样,我们也用e_putchar()来代替我们平常使用的putchar().这里"e"的意思就是"example". 没有了main函数,我们的C程序就没有了入口,所以在开始编译这段C代码之前,我还得写几行简单的汇编代码,通过它来作为我们程序的入口. ; C程序的入口start.asm [BITS 16] [global start] [extern _e_main] start: call _e_main 按照C语言的习惯,所以C总的名词都要自动在前面加一个"_"下划线.所以,我们在C中的e_main函数,如果要在汇编中调用,就变成了_e_main函数.这段汇编代码只有一句:call _e_main,就是调用我们在C中的e_main函数
C语言入门教程10(函数参数的传递和值的返回)
前面我们说的都是无参数无返回值的函数，实际程序中，我们经常使用到带参数有返回值的函数。 一、函数参数传递 1.形式参数和实际参数 函数的调用值把一些表达式作为参数传递给函数。函数定义中的参数是形式参数，函数的调用者提供给函数的参数叫实际参数。在函数调用之前，实际参数的值将被拷贝到这些形式参数中。 2.参数传递 先看一个例子： void a(int); /*注意函数声明的形式*/ main() { int num; scanf(%d,&num); a(num); /*注意调用形式*/ } void a(int num_back) /*注意定义形式*/ { printf(%d\n,num_back); } 在主函数中，先定义一个变量，然后输入一个值，在a()这个函数中输出。当程序运行a(num);这一步时，把num的值赋值给num_back，在运行程序过程中，把实际参数的值传给形式参数，这就是函数参数的传递。 形参和实参可能不只一个，如果多于一个时，函数声明、调用、定义的形式都要一一对应，不仅个数要对应，参数的数据类型也要对应。 void a(int,float); main() { int num1; float num2; scanf(%d,&num1); scanf(%f,&num2); a(num1,num2); } void a(int num1_back,float num2_back) { printf(%d,%f\n,num1_back,num2_back);
} 上面的例子中，函数有两个参数，一个是整型，一个是浮点型，那么在声明、调用、定义的时候，不仅个数要一样，类型也要对应。如果不对应，有可能使的编译错误，即使没错误，也有可能让数据传递过程中出现错误。 再看一个例子： void a(int); main() { int num; scanf(%d,&num); a(num); } void a(int num) { printf(%d\n,num); } 看上面的例子，形式参数和实际参数的标识符都是num，程序把实际参数num的值传递给形式参数num。有些人可能就不明白了，既然两个都是num，为什么还要传递呢？干脆这样不就行了吗： void a(); main() { int num; scanf(%d,&num); a(); } void a() { printf(%d\n,num); } 其实不然，这就要涉及到标识符作用域的问题。作用域的意思就是说，哪些变量在哪些范围内有效。一个标识符在一个语句块中声明，那么这个标识符仅在当前和更低的语句块中可见，在函数外部的其实地方不可见，其他地方同名的标识符不受影响，后面我们会系统讲解作用域的问题。在这儿你就要知道两个同名的变量在不同的函数中是互不干扰的。
SpringMVC向页面传递参数的4种方式
SpringMVC向页面传递参数的4种方式 1、使用HttpServletRequest和Session 然后setAttribute()，就和Servlet 中一样 request.setAttribute(“user”,user_data); 2、使用ModelAndView对象 @RequestMapping("/login.do") publicModelAndView login(String name,String pass) { User user = userService.login(name,pwd); Map
c语言函数调用三种方式传值调用,引用调用和传地址调
C语言函数调用三种方式传值调用,引用调用和传地址调 我想，你只要看了C语言上关于传值函数调用的测试题，一切都会了然于胸：1. 考题一：程序代码如下： void Exchg1(int x, int y) { int tmp; tmp=x; x=y; y=tmp; printf(“x=%d,y=%d\n”,x,y) } void main() { int a=4,b=6; Exchg1 (a,b) ; printf(“a=%d,b=%d\n”,a,b) } 输出的结果： x=____, y=____ a=____, b=____ 问下划线的部分应是什么，请完成。 2. 考题二：代码如下。 Exchg2(int *px, int *py) { int tmp=*px; *px=*py; *py=tmp; print(“*px=%d,*py=%d\n”,*px,*py); } main() { int a=4; int b=6; Exchg2(&a,&b); Print(“a=%d,b=%d\n”, a, b); }
输出的结果为： *px=____, *py=____ a=____, b=____ 问下划线的部分应是什么，请完成。 3. 考题三： Exchg2(int &x, int &y) { int tmp=x; x=y; y=tmp; print(“x=%d,y=%d\n”,x,y); } main() { int a=4; int b=6; Exchg2(a,b); Print(“a=%d,b=%d\n”, a, b); } 二．函数参数传递方式之一：值传递 1．值传递的一个错误认识 先看题一中Exchg1函数的定义： void Exchg1(int x, int y) //定义中的x,y变量被称为Exchg1函数的形式参数{ int tmp; tmp=x; x=y; y=tmp; printf(“x=%d,y=%d\n”,x,y) } 问：你认为这个函数是在做什么呀 答：好像是对参数x,y的值对调吧 请往下看，我想利用这个函数来完成对a,b两个变量值的对调，程序如下：void main() {
C语言调用汇编语言时变量的传递
F2812中C语言调用汇编函数 参考资料： (1) SPRU514 ---- TMS320F28x Optimizing C／C++ Compiler User’s Guide.pdf; (2) spru430d ---- TMS320C28x DSP CPU and Instruction Set Reference Guide; (3) spru513c ---- TMS320C28x Assembly Language Tools User's Guide. 一、编写C语言能调用的.asm文件 以delay.asm为例： 1、将文件保存为.asm文件； 2、在文件中编写如下代码： ;********************************************************** ***********/ ;* 鲍正华*/ ;* 2010.07.09 */
;********************************************************** ***********/ ;//######################################################### ################## ; @FunctionName: Delay_asm ; ; @Brief: 延时1s ; ; @Param: unsigned long cnt 传给ACC ; ; @Return: 无 ;//######################################################### ################## .def _Delay_asm .global _Delay_asm
- 数组名 作为 函数参数 实现地址 传递方式 实现将任意 两个字符串连接成一个字符串 p222
- C语言中参数传递
- 指针与参数传递
- 函数参数的传递方式
- 25-变量作为函数的参数进行传递.解答
- 函数间数据传递方式
- 函数参数的传递和值返回
- 函数参数传递的原理
- c语言值传递的3种形式
- C++语言中函数参数传递方式的图示说明
- C、C++函数参数传递方式
- 函数参数的传递方式PPT课件
- c语言函数调用三种方式传值调用,引用调用和传地址调
- 25-变量作为函数的参数进行传递
- C++中函数调用时的三种参数传递方式
- 总结Java方法(函数)传值和传引用的问题
- 深入了解C语言(函数的参数传递和函数使用参数的方法)
- 函数的参数传递方式
- 函数的参数传递几种不同情况的比较
- 函数调用时参数传递方式