常见函数调用约定(x86、x64、arm、arm64)

最新推荐文章于 2025-02-07 20:05:19 发布
置顶 最新推荐文章于 2025-02-07 20:05:19 发布
阅读量7.7k 收藏 16
点赞数 4
分类专栏： 反汇编分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a565499699/article/details/79294261
版权
本文详细介绍了X86平台上的cdecl、stdcall和fastcall三种函数调用约定，以及X64平台上的fastcall调用约定。通过具体的代码示例，解释了不同约定下参数传递方式、栈平衡处理及返回值存储的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

我学习逆向，整理的一些常见的函数调用约定反汇编笔记。由于我是新手，肯定有一些疏漏不完善的，我遇到了会实时更新的。

X86 函数调用约定

X86 有三种常用调用约定，cdecl(C规范)/stdcall(WinAPI默认)/fastcall 函数调用约定。

cdecl 函数调用约定

参数从右往左一次入栈，调用者实现栈平衡，返回值存放在 EAX 中。

20:       int cdecl_sum = cdecl_add(1, 2, 3, 4, 5, 6, 7);
00401138   push        7
0040113A   push        6
0040113C   push        5
0040113E   push        4
00401140   push        3
00401142   push        2
00401144   push        1
00401146   call        @ILT+5(_cdecl_add) (0040100a)
0040114B   add         esp,1Ch  # 栈平衡
0040114E   mov         dword ptr [ebp-4],eax    # 返回值

3:    int __cdecl cdecl_add(int a, int b, int c, int d, int e, int f, int g)
4:    {
00401030   push        ebp
00401031   mov         ebp,esp
00401033   sub         esp,44h
00401036   push        ebx
00401037   push        esi
00401038   push        edi
00401039   lea         edi,[ebp-44h]
0040103C   mov         ecx,11h
00401041   mov         eax,0CCCCCCCCh
00401046   rep stos    dword ptr [edi]
5:        int sum = a+b+c+d+e+f+g;
00401048   mov         eax,dword ptr [ebp+8]
0040104B   add         eax,dword ptr [ebp+0Ch]
0040104E   add         eax,dword ptr [ebp+10h]
00401051   add         eax,dword ptr [ebp+14h]
00401054   add         eax,dword ptr [ebp+18h]
00401057   add         eax,dword ptr [ebp+1Ch]
0040105A   add         eax,dword ptr [ebp+20h]
0040105D   mov         dword ptr [ebp-4],eax
6:        return sum;
00401060   mov         eax,dword ptr [ebp-4]    # 存放返回值
7:    }
00401063   pop         edi
00401064   pop         esi
00401065   pop         ebx
00401066   mov         esp,ebp
00401068   pop         ebp
00401069   ret
stdcall 函数调用约定

参数从右往左一次入栈，被调用者实现栈平衡，返回值存放在 EAX 中。

21:       int stdcall_sum = stdcall_add(1, 2, 3, 4, 5, 6, 7);
00401151   push        7
00401153   push        6
00401155   push        5
00401157   push        4
00401159   push        3
0040115B   push        2
0040115D   push        1
0040115F   call        @ILT+15(_stdcall_add@28) (00401014)
00401164   mov         dword ptr [ebp-8],eax    # 返回值

9:    int __stdcall stdcall_add(int a, int b, int c, int d, int e, int f, int g)
10:   {
00401080   push        ebp
00401081   mov         ebp,esp
00401083   sub         esp,44h
00401086   push        ebx
00401087   push        esi
00401088   push        edi
00401089   lea         edi,[ebp-44h]
0040108C   mov         ecx,11h
00401091   mov         eax,0CCCCCCCCh
00401096   rep stos    dword ptr [edi]
11:       int sum = a+b+c+d+e+f+g;
00401098   mov         eax,dword ptr [ebp+8]
0040109B   add         eax,dword ptr [ebp+0Ch]
0040109E   add         eax,dword ptr [ebp+10h]
004010A1   add         eax,dword ptr [ebp+14h]
004010A4   add         eax,dword ptr [ebp+18h]
004010A7   add         eax,dword ptr [ebp+1Ch]
004010AA   add         eax,dword ptr [ebp+20h]
004010AD   mov         dword ptr [ebp-4],eax
12:       return sum;
004010B0   mov         eax,dword ptr [ebp-4]    # 存放返回值
13:   }
004010B3   pop         edi
004010B4   pop         esi
004010B5   pop         ebx
004010B6   mov         esp,ebp
004010B8   pop         ebp
004010B9   ret         1Ch  # 栈平衡（等价于先 add esp, 1Ch 再 ret）
fastcall 函数调用约定

参数1、参数2分别保存在 ECX、EDX ，剩下的参数从右往左一次入栈，被调用者实现栈平衡，返回值存放在 EAX 中。

25:       int fastcall_sum = fastcall_add(1, 2, 3, 4, 5, 6, 7);
00401167   push        7
00401169   push        6
0040116B   push        5
0040116D   push        4
0040116F   push        3
00401171   mov         edx,2
00401176   mov         ecx,1
0040117B   call        @ILT+0(@fastcall_add@28) (00401005)
00401180   mov         dword ptr [ebp-0Ch],eax  # 返回值

15:   int __fastcall fastcall_add(int a, int b, int c, int d, int e, int f, int g)
16:   {
004010D0   push        ebp
004010D1   mov         ebp,esp
004010D3   sub         esp,4Ch
004010D6   push        ebx
004010D7   push        esi
004010D8   push        edi
004010D9   push        ecx
004010DA   lea         edi,[ebp-4Ch]
004010DD   mov         ecx,13h
004010E2   mov         eax,0CCCCCCCCh
004010E7   rep stos    dword ptr [edi]
004010E9   pop         ecx
004010EA   mov         dword ptr [ebp-8],edx
004010ED   mov         dword ptr [ebp-4],ecx
17:       int sum = a+b+c+d+e+f+g;
004010F0   mov         eax,dword ptr [ebp-4]
004010F3   add         eax,dword ptr [ebp-8]
004010F6   add         eax,dword ptr [ebp+8]
004010F9   add         eax,dword ptr [ebp+0Ch]
004010FC   add         eax,dword ptr [ebp+10h]
004010FF   add         eax,dword ptr [ebp+14h]
00401102   add         eax,dword ptr [ebp+18h]
00401105   mov         dword ptr [ebp-0Ch],eax
18:       return sum;
00401108   mov         eax,dword ptr [ebp-0Ch]  # 存放返回值
19:   }
0040110B   pop         edi
0040110C   pop         esi
0040110D   pop         ebx
0040110E   mov         esp,ebp
00401110   pop         ebp
00401111   ret         14h  # 栈平衡（等价于先 add esp, 14h 再 ret）

X64 函数调用约定

X64只有一种 fastcall 函数调用约定

fastcall 函数调用约定

参数1、参数2、参数3、参数4分别保存在 RCX、RDX、R8D、R9D ，剩下的参数从右往左一次入栈，被调用者实现栈平衡，返回值存放在 RAX 中。

# 该代码是 msvc 2017 x64 生成的汇编代码
    int fastcall_sum = fastcall_add(1, 2, 3, 4, 5, 6, 7); 
00007FF6577A366E  mov         dword ptr [rsp+30h],7
00007FF6577A3676  mov         dword ptr [rsp+28h],6  
00007FF6577A367E  mov         dword ptr [rsp+20h],5  
00007FF6577A3686  mov         r9d,4  
00007FF6577A368C  mov         r8d,3  
00007FF6577A3692  mov         edx,2  
00007FF6577A3697  mov         ecx,1  
00007FF6577A369C  call        fastcall_add (07FF6577A11C2h)  
00007FF6577A36A1  mov         dword ptr [fastcall_sum],eax  # 返回值

int __fastcall fastcall_add(int a, int b, int c, int d, int e, int f, int g)
{
00007FF6D22D1790  mov         dword ptr [rsp+20h],r9d  
00007FF6D22D1795  mov         dword ptr [rsp+18h],r8d  
00007FF6D22D179A  mov         dword ptr [rsp+10h],edx  
00007FF6D22D179E  mov         dword ptr [rsp+8],ecx  
00007FF6D22D17A2  push        rbp  
00007FF6D22D17A3  push        rdi  
00007FF6D22D17A4  sub         rsp,0E8h  
00007FF6D22D17AB  mov         rbp,rsp  
00007FF6D22D17AE  mov         rdi,rsp  
00007FF6D22D17B1  mov         ecx,3Ah  
00007FF6D22D17B6  mov         eax,0CCCCCCCCh  
00007FF6D22D17BB  rep stos    dword ptr [rdi]  
00007FF6D22D17BD  mov         ecx,dword ptr [rsp+108h]  
    int sum = a + b + c + d + e + f + g;
00007FF6D22D17C4  mov         eax,dword ptr [b]  
00007FF6D22D17CA  mov         ecx,dword ptr [a]  
00007FF6D22D17D0  add         ecx,eax  
00007FF6D22D17D2  mov         eax,ecx  
00007FF6D22D17D4  add         eax,dword ptr [c]  
00007FF6D22D17DA  add         eax,dword ptr [d]  
00007FF6D22D17E0  add         eax,dword ptr [e]  
00007FF6D22D17E6  add         eax,dword ptr [f]  
00007FF6D22D17EC  add         eax,dword ptr [g]  
00007FF6D22D17F2  mov         dword ptr [sum],eax  
    return sum;
00007FF6D22D17F5  mov         eax,dword ptr [sum]       # 存放返回值
}
00007FF6D22D17F8  lea         rsp,[rbp+0E8h]  
00007FF6D22D17FF  pop         rdi  
00007FF6D22D1800  pop         rbp  
00007FF6D22D1801  ret                                   # 没做栈平衡

C++ 函数调用约定

thiscall用于C++中类成员函数（方法）的调用

thiscall 函数调用约定

暂时不懂C++，等学了C++类了再更新

ARM/ARM64 函数调用约定

ARM和ARM64使用的是ATPCS(ARM-Thumb Procedure Call Standard/ARM-Thumb过程调用标准)的函数调用约定。

ATPCS 函数调用约定
ARM

参数1~参数4 分别保存到 R0~R3 寄存器中 ，剩下的参数从右往左一次入栈，被调用者实现栈平衡，返回值存放在 R0 中。

; 该代码是 arm-linux-androideabi-gcc + IDA PRO 生成的反汇编代码
.text:00008438                 MOV             R3, #5
.text:0000843C                 STR             R3, [SP,#0x1C+e] ; e
.text:00008440                 MOV             R3, #6
.text:00008444                 STR             R3, [SP,#0x1C+f] ; f
.text:00008448                 MOV             R3, #7
.text:0000844C                 STR             R3, [SP,#0x1C+g] ; g
.text:00008450                 MOV             R0, #1  ; a
.text:00008454                 MOV             R1, #2  ; b
.text:00008458                 MOV             R2, #3  ; c
.text:0000845C                 MOV             R3, #4  ; d
.text:00008460                 BL              add
.text:00008464                 STR             R0, [R11,#sum]

.text:000083C4                 EXPORT add
.text:000083C4                 STR             R11, [SP,#-4+var_s0]!
.text:000083C8                 ADD             R11, SP, #0
.text:000083CC                 SUB             SP, SP, #0x1C
.text:000083D0                 STR             R0, [R11,#a]
.text:000083D4                 STR             R1, [R11,#b]
.text:000083D8                 STR             R2, [R11,#c]
.text:000083DC                 STR             R3, [R11,#d]
.text:000083E0                 LDR             R2, [R11,#a]
.text:000083E4                 LDR             R3, [R11,#b]
.text:000083E8                 ADD             R2, R2, R3
.text:000083EC                 LDR             R3, [R11,#c]
.text:000083F0                 ADD             R2, R2, R3
.text:000083F4                 LDR             R3, [R11,#d]
.text:000083F8                 ADD             R2, R2, R3
.text:000083FC                 LDR             R3, [R11,#e]
.text:00008400                 ADD             R2, R2, R3
.text:00008404                 LDR             R3, [R11,#f]
.text:00008408                 ADD             R2, R2, R3
.text:0000840C                 LDR             R3, [R11,#g]
.text:00008410                 ADD             R3, R2, R3
.text:00008414                 STR             R3, [R11,#sum]
.text:00008418                 LDR             R3, [R11,#sum]
.text:0000841C                 MOV             R0, R3          ; R0返回值
.text:00008420                 SUB             SP, R11, #0
.text:00008424                 LDR             R11, [SP+var_s0],#4
.text:00008428                 BX              LR
ARM64

参数1~参数8 分别保存到 X0~X7 寄存器中 ，剩下的参数从右往左一次入栈，被调用者实现栈平衡，返回值存放在 X0 中。

; 该代码是 aarch64-linux-android-gcc + IDA PRO 生成的反汇编代码
.text:0000000000400684                 MOV             W0, #9
.text:0000000000400688                 STR             W0, [SP,#0x40+i] ; i
.text:000000000040068C                 MOV             W0, #10
.text:0000000000400690                 STR             W0, [SP,#0x40+j] ; j
.text:0000000000400694                 MOV             W0, #11
.text:0000000000400698                 STR             W0, [SP,#0x40+k] ; k
.text:000000000040069C                 MOV             W0, #12
.text:00000000004006A0                 STR             W0, [SP,#0x40+l] ; l
.text:00000000004006A4                 MOV             W0, #1  ; a
.text:00000000004006A8                 MOV             W1, #2  ; b
.text:00000000004006AC                 MOV             W2, #3  ; c
.text:00000000004006B0                 MOV             W3, #4  ; d
.text:00000000004006B4                 MOV             W4, #5  ; e
.text:00000000004006B8                 MOV             W5, #6  ; f
.text:00000000004006BC                 MOV             W6, #7  ; g
.text:00000000004006C0                 MOV             W7, #8  ; h
.text:00000000004006C4                 BL              add
.text:00000000004006C8                 STR             W0, [X29,#0x20+sum]

.text:00000000004005E8                 EXPORT add
.text:00000000004005E8
.text:00000000004005E8                 SUB             SP, SP, #0x30
.text:00000000004005EC                 STR             W0, [SP,#0x30+a]
.text:00000000004005F0                 STR             W1, [SP,#0x30+b]
.text:00000000004005F4                 STR             W2, [SP,#0x30+c]
.text:00000000004005F8                 STR             W3, [SP,#0x30+d]
.text:00000000004005FC                 STR             W4, [SP,#0x30+e]
.text:0000000000400600                 STR             W5, [SP,#0x30+f]
.text:0000000000400604                 STR             W6, [SP,#0x30+g]
.text:0000000000400608                 STR             W7, [SP,#0x30+h]
.text:000000000040060C                 LDR             W1, [SP,#0x30+a]
.text:0000000000400610                 LDR             W0, [SP,#0x30+b]
.text:0000000000400614                 ADD             W1, W1, W0
.text:0000000000400618                 LDR             W0, [SP,#0x30+c]
.text:000000000040061C                 ADD             W1, W1, W0
.text:0000000000400620                 LDR             W0, [SP,#0x30+d]
.text:0000000000400624                 ADD             W1, W1, W0
.text:0000000000400628                 LDR             W0, [SP,#0x30+e]
.text:000000000040062C                 ADD             W1, W1, W0
.text:0000000000400630                 LDR             W0, [SP,#0x30+f]
.text:0000000000400634                 ADD             W1, W1, W0
.text:0000000000400638                 LDR             W0, [SP,#0x30+g]
.text:000000000040063C                 ADD             W1, W1, W0
.text:0000000000400640                 LDR             W0, [SP,#0x30+h]
.text:0000000000400644                 ADD             W1, W1, W0
.text:0000000000400648                 LDR             W0, [SP,#0x30+i]
.text:000000000040064C                 ADD             W1, W1, W0
.text:0000000000400650                 LDR             W0, [SP,#0x30+j]
.text:0000000000400654                 ADD             W1, W1, W0
.text:0000000000400658                 LDR             W0, [SP,#0x30+k]
.text:000000000040065C                 ADD             W1, W1, W0
.text:0000000000400660                 LDR             W0, [SP,#0x30+l]
.text:0000000000400664                 ADD             W0, W1, W0
.text:0000000000400668                 STR             W0, [SP,#0x30+sum]
.text:000000000040066C                 LDR             W0, [SP,#0x30+sum]   ;X0 返回值
.text:0000000000400670                 ADD             SP, SP, #0x30
.text:0000000000400674                 RET
【arm】常见函数调用约定(x86、x64、arm、arm64)
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
09-20 1879
Date: 2018.9.20 1、X86 函数调用约定 X86 有三种常用调用约定，cdecl(C规范)/stdcall(WinAPI默认)/fastcall 函数调用约定。详细可参考： 函数调用协议__cdecl,__fastcall,__stdcall。 其中： Cdecl调用规范：参数从右往左一次入栈，调用者实现栈平衡，返回值存放在 EAX 中。 stdcall调用规范：参数从右往左一...
ARM学习（17）ARM函数调用规则
张一西的博客
01-31 2381
ARM 函数调用规则
ARM64汇编0B - 函数调用约定
a5right的博客
06-20 732
建议先看《CSAPP》的3.7节，讲的很细。我们这里就直接看例子来分析了。
arm函数调用约定
crlyn的博客
12-14 3239
要想理解汇编代码，首先重要的事情就是理解代码之间的交互——意思是一个函数调用另一个函数的方式。这包括了参数如何传递以及如何从函数返回结果——称之为调用的约定。编译器必须严格的遵守相关标准进行代码编译，这样生成的代码，才能够相互兼容。 上面讨论过，寄存器是的存储空间非常少，并且靠近CPU——用来存储当前使用的一些值。ARM CPU有16个寄存器：r0到r15。每个寄存器为32bit。调用约定规定了
理解ARM64EC非官方重要文档
最新发布
weixin_46486440的博客
02-07 1639
ARM64X二进制文件中包含的x64和ARM64字节码的混合由构建二进制文件的开发人员决定——它可以包含几乎100%的ARM64代码，只有少量的x64入口点（这是理想情况），也可以在光谱的另一端，几乎100%的x64代码，只有少量的ARM64EC入口点（这是项目早期移植的情况）。这意味着我的xtabase仿真器可以直接调用C:\Windows\System32中的本地ARM64二进制文件的函数入口点，并按原样传递指针和数据结构——不需要单独的x64二进制文件，不需要胖二进制文件，不需要WOW64层。
ARM体系结构学习笔记：过程调用标准AAPC、 ARM32调用约定、ARM64调用约定
热情、奔放、快乐编程！
08-21 610
参数传递的本质: 将上层函数变量复制一份, 传给下层函数.
x86_64汇编之四：函数调用、调用约定
qq_29328443的博客
07-09 1万+
一、栈 栈一般从高地址往低地址生长，每个函数都在栈空间中对应一个栈帧。关于栈帧有两个重要的指针——栈基址指针BP和栈顶指针SP。其中，除了在函数的开头和结尾（后面会讲到），BP指针一般是固定不变的，通常以它为基准来寻址参数和局部变量，例如将第一个参数放入栈中的汇编代码可以是movq %rdi, -8(%rbp)。 和栈相关的两个指令是push和pop。在x86_64架构的计算机上，push operand指令的作用是： 将栈顶指针rsp减去8（即8字节） 然后将目标操作数放入更新后的rsp所指向的地址
逆向基础（一）--- 函数调用协议汇总X86/X64/ARM/ARM64
移动（IoT）安全
07-16 1万+
X86 函数调用约定 函数调用协议会影响函数参数的入栈方式、栈内数据的清除方式、编译器函数名的修饰规则。如下图所示，可以在IDE环境中设定所有函数默认的调用协议，还可以在函数定义时单独设定本函数的调用协议。 调用协议常用场合 __stdcall：Windows API默认的函数调用协议。 __cdecl：C/C++默认的函数调用协议。 __fastcall：适用于对性能要求较高的场合。 函数参数入栈方式 __stdcall：函数参数由右向左入栈。 __cdecl：函数参数由右向左入栈。
函数调用协议汇总X86X64ARMARM64二进制文件.zip
07-16
函数调用协议汇总X86/X64/ARM/ARM64文章内实例二进制文件 文章链接： https://blog.csdn.net/m0_49364644/article/details/107377587
ios平台的支持arm64和x86-64的通用openssl静态库
01-13
在iOS设备中，处理器架构主要分为ARM架构和Intel架构，其中ARM架构包括armv7、armv7s和arm64，而Intel架构则包括i386和x86_64。 为了确保iOS应用的广泛兼容性，开发者需要构建一个支持上述所有架构的通用OpenSSL...
opencv4 , 包含的arm64-v8a、armeabi-v7a、x86、x86_64的so库
04-16
2. **arm64-v8a**：这是Android的一种架构，适用于基于ARM64位处理器的设备，如现代的高端智能手机和平板电脑。arm64-v8a库是为这些设备编译的，能够利用64位计算的优势，提供更好的性能。 3. **armeabi-v7a**：...
X86/X64 函数调用约定
aijuzhou1959的博客
03-11 336
C语言有__cdecl、__stdcall、__fastcall、naked、__pascal。 C++语言有__cdecl、__stdcall、__fastcall、naked、__pascal、__thiscall，比C语言多出一种__thiscall调用方式。 下面详细介绍如上六种调用方式： 1、__cdecl __cdecl调用约定又称为C调用约定，是...
深入理解ARM64的函数调用标准与栈布局
代码背包客的博客
07-07 1764
函数调用标准(Procedure Call Standard, PCS)是指在函数调用过程中，对父/子函数如何编译以及链接做一些规范和约定。如参数的传递，返回值处理、寄存器的使用和栈的布局等。函数调用标准定义了函数调用的具体实现机制。对于不同的处理器架构都有不同的函数调用标准，本文我们将讲解关于ARM64的函数调用标准。是一份描述ARM64架构函数调用的标准和规范文档。该文档网址地址点这里。每个函数(同时具有caller和callee)的栈结构格式栈顶保存的是自己的栈帧基地址，即指向上一个栈帧的栈顶。
Neon 指令集 ARMv7/v8 对比
热门推荐
蓝色污点的专栏
05-18 4万+
原文：http://community.arm.com/groups/android-community/blog/2015/03/27/arm-neon-programming-quick-reference ARM NEON programming quick reference 1 Introduction This article aims to in
关于函数调用约定
墨云斋
10-28 598
调用约定，即调用方式影响调用函数时参数的传递方式和函数后栈的回复访求，    几种约定：          _cdecl；_stdcall；_fastcall        入栈：    前两者都是参数从右向左入栈，后者使用ECX，EDX，寄存器传递，余下部分翻出从右向左存入栈。   恢复栈： _cdecl:是有调用者将esp和ebp指令恢复到调用前状态；
x64 和 arm64 处理器架构的区别
2007 年 ~ 2025 年，深耕 SAP 技术 18 年
03-03 2830
在深入探讨 x64 和 arm64 这两个处理器架构之前，让我们先明确它们在计算机科学和硬件设计领域中的基本概念和重要性。理解这些概念对于掌握它们的区别至关重要，而且可以帮助我们认识到为什么现代计算设备，从服务器到智能手机，会选择这些架构。x64，也被称为AMD64或Intel 64，是对经典的32位x86指令集架构（ISA）的扩展。这种架构最初由AMD开发，并迅速被Intel采纳，其主要目的是允许计算机处理更大的内存空间（超过4GB），同时保持对旧x86应用程序的兼容性。x64架构支持的是64。
x64和ARM的区别
qq_70531838的博客
06-13 8789
**x64**：x64架构的操作系统，如Windows-amd64、Linux x86\_64等，可以运行32位和64位的x86应用程序。* **ARM**：ARM架构的操作系统，如Windows-arm64、Linux ARM64等，通常只能运行专为ARM架构编译的应用程序。* **ARM**：ARM架构属于精简指令集计算（RISC），指令集较为简单，每条指令执行单一操作，这有助于提高指令的执行速度和效率。总结来说，x64和ARM架构各有优势，适用于不同的应用场景。
C/C++中函数调用规则（约定）__cdecl __stdcall __thiscall __vectorcall __fastcall __clrcall
Baoli1008的专栏
02-06 4121
转自https://my.oschina.net/ray1421/blog/699540 相关文献 __stdcall https://msdn.microsoft.com/en-us/library/zxk0tw93.aspx C语言函数可变参数详解 - ranpanf的专栏 - 博客频道 - CSDN.NET http://blog.csdn.net/ranpanf/arti
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值