C/C++、C#、F#、Go AMD x86-64 编译器内部实现乘法运算

已于 2022-11-05 11:58:49 修改
阅读量659 收藏
点赞数
分类专栏： C/C++ C# 文章标签： c++ 开发语言 visual studio
于 2022-11-05 11:50:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/127700862
版权
C/C++ 同时被 2 个专栏收录
268 篇文章 7 订阅
订阅专栏
C#
94 篇文章 2 订阅
订阅专栏

我们知道任何编译器语言都不是直接编译 “目标CPU平台汇编机器字节码”（汇编），哪怕是：C/C++ 编译器也是相同的，需要预编译为ASM汇编文本源码后，提交输入ASM编译器进行静态编译，VC++ CL内集MASM编译器。

而本文的获取的不同语言执行汇编代码就是这个步骤的由编译器生成的源码。

原型表达式：C/C++

int mul(int x, int y) { return x * y; }

原型表达式：Go

package main

func mul(x int, y int) int {
    return x * y
}

func main() {}

原型表达式：C#

class Program
{
    static int mul(int x, int y) => x * y;
}

原型表达式：F#

module Program

let mul(x, y) = x * y

C/C++ on x86-64 clang 6.0.0

mul(int, int):                               # @mul(int, int)
        imul    edi, esi
        mov     eax, edi
        ret

C/C++ on MSVC V19.10 WINE（VC++ 2019, ##VC++ 2022 version greater !19.29.30140.0）

x$ = 8
y$ = 16
int mul(int,int) PROC                                  ; mul
        imul    ecx, edx
        mov     eax, ecx
        ret     0
int mul(int,int) ENDP                                  ; mul

C# .NET 6.0（dotnet core）

Program:.ctor():this:
       ret      

Program:mul(int,int):int:
       mov      eax, edi
       imul     eax, esi
       ret

C# .NET Framework 4.0 JIT （Intel x86-32）DEBUG【会有无效CPU指令】

static int mul(int x, int y) => x * y;

## 完整函数实现(等价于上面其它语言ASM被编译为最终机器代码)
0516B040 55                   push        ebp  
0516B041 8B EC                mov         ebp,esp  // 部署函数堆栈
0516B043 57                   push        edi  
0516B044 56                   push        esi  
0516B045 53                   push        ebx  
0516B046 83 EC 34             sub         esp,34h  // 扩大52字节计算堆栈
0516B049 33 C0                xor         eax,eax  // 置空(位运算同值异或)

## 复制计算堆栈的值（X，Y）两个变量到函数局部变量计算堆栈上及函数计算堆栈的初始化
0516B04B 89 45 F0             mov         dword ptr [ebp-10h],eax  
0516B04E 89 45 E4             mov         dword ptr [ebp-1Ch],eax  
0516B051 89 4D C4             mov         dword ptr [ebp-3Ch],ecx  
0516B054 89 55 C0             mov         dword ptr [ebp-40h],edx  
0516B057 83 3D F0 42 E8 00 00 cmp         dword ptr ds:[0E842F0h],0  
0516B05E 74 05                je          Ppp.Windows.PppApplication+Program.mul(Int32, Int32)+025h (0516B065h)  
0516B060 E8 0B 2C EB 6D       call        7301DC70  

## 该C#函数做工乘法运算执行汇编的指令（很清晰）；
0516B065 8B 45 C0             mov         eax,dword ptr [ebp-40h]  
0516B068 0F AF 45 C4          imul        eax,dword ptr [ebp-3Ch]  

## 平衡函数堆栈并返回，注：EAX累加寄存器在X86汇编中常用于代表返回值
0516B06C 8D 65 F4             lea         esp,[ebp-0Ch]  
0516B06F 5B                   pop         ebx  
0516B070 5E                   pop         esi  
0516B071 5F                   pop         edi  
0516B072 5D                   pop         ebp  
0516B073 C3                   ret         ## 等价：RETN 0（就是上面未编译为机器汇编的源文本形式的：ret 0）

F# on dotNET Native AOT

Program:mul(int,int):int:
       mov      eax, edi
       imul     eax, esi
       ret

Golang on x86 gccgo 12.2.20（打开编译器最大代码编译优化级别）

剔除其它代码至少需要执行以下的源汇编指令，这就只是做个 X, Y 简单的乘法运算而已.....

main.mul:
        cmp     rsp, QWORD PTR fs:112
        jb      .L125
.L124:
        mov     rax, rdi
        imul    rax, rsi
        ret
.L125:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L124

编译器生成完整汇编源代码：

main.struct_4runtime_0gList_cruntime_0n_bint32_5..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L6
.L4:
        mov     rdx, QWORD PTR [rsi]
        xor     eax, eax
        cmp     QWORD PTR [rdi], rdx
        jne     .L1
        mov     eax, DWORD PTR [rsi+8]
        cmp     DWORD PTR [rdi+8], eax
        sete    al
.L1:
        ret
.L6:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L4
main._661_7struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L16
.L15:
        xor     edx, edx
.L9:
        mov     r9, QWORD PTR [rdi+8+rdx]
        mov     r8, QWORD PTR [rdi+16+rdx]
        mov     rax, QWORD PTR [rsi+8+rdx]
        mov     rcx, QWORD PTR [rsi+16+rdx]
        mov     r10d, DWORD PTR [rsi+rdx]
        cmp     DWORD PTR [rdi+rdx], r10d
        je      .L17
        xor     eax, eax
.L7:
        ret
.L17:
        cmp     r9, rax
        sete    al
        cmp     r8, rcx
        sete    cl
        and     al, cl
        je      .L7
        add     rdx, 24
        cmp     rdx, 1464
        jne     .L9
        ret
.L16:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L15
main.struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L23
.L22:
        mov     edx, DWORD PTR [rsi]
        xor     eax, eax
        cmp     DWORD PTR [rdi], edx
        jne     .L18
        mov     rcx, QWORD PTR [rsi+8]
        cmp     QWORD PTR [rdi+8], rcx
        je      .L24
.L18:
        ret
.L24:
        mov     rax, QWORD PTR [rsi+16]
        cmp     QWORD PTR [rdi+16], rax
        sete    al
        ret
.L23:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L22
main._633_7float64..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L33
.L32:
        xor     eax, eax
        jmp     .L28
.L35:
        add     rax, 8
        cmp     rax, 264
        je      .L34
.L28:
        movsd   xmm0, QWORD PTR [rdi+rax]
        ucomisd xmm0, QWORD PTR [rsi+rax]
        jp      .L29
        je      .L35
.L29:
        xor     eax, eax
        ret
.L34:
        mov     eax, 1
        ret
.L33:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L32
main._632_7uintptr..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L39
.L37:
        sub     rsp, 8
        mov     edx, 256
        call    runtime.memequal
        add     rsp, 8
        ret
.L39:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L37
main._6256_7uint64..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L43
.L41:
        sub     rsp, 8
        mov     edx, 2048
        call    runtime.memequal
        add     rsp, 8
        ret
.L43:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L41
main._6122_7uintptr..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L47
.L45:
        sub     rsp, 8
        mov     edx, 976
        call    runtime.memequal
        add     rsp, 8
        ret
.L47:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L45
main._68_7uint64..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L51
.L49:
        sub     rsp, 8
        mov     edx, 64
        call    runtime.memequal
        add     rsp, 8
        ret
.L51:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L49
main._6128_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L55
.L53:
        sub     rsp, 8
        mov     edx, 128
        call    runtime.memequal
        add     rsp, 8
        ret
.L55:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L53
main._64096_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L59
.L57:
        sub     rsp, 8
        mov     edx, 4096
        call    runtime.memequal
        add     rsp, 8
        ret
.L59:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L57
main._668_7uint16..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L63
.L61:
        sub     rsp, 8
        mov     edx, 136
        call    runtime.memequal
        add     rsp, 8
        ret
.L63:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L61
main._665_7uint32..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L67
.L65:
        sub     rsp, 8
        mov     edx, 260
        call    runtime.memequal
        add     rsp, 8
        ret
.L67:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L65
main._64_7uintptr..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L71
.L69:
        sub     rsp, 8
        mov     edx, 32
        call    runtime.memequal
        add     rsp, 8
        ret
.L71:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L69
main._65_7uint..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L75
.L73:
        sub     rsp, 8
        mov     edx, 40
        call    runtime.memequal
        add     rsp, 8
        ret
.L75:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L73
main._6512_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L79
.L77:
        sub     rsp, 8
        mov     edx, 512
        call    runtime.memequal
        add     rsp, 8
        ret
.L79:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L77
main._6249_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L83
.L81:
        sub     rsp, 8
        mov     edx, 249
        call    runtime.memequal
        add     rsp, 8
        ret
.L83:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L81
main._6129_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L87
.L85:
        sub     rsp, 8
        mov     edx, 129
        call    runtime.memequal
        add     rsp, 8
        ret
.L87:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L85
main._632_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L91
.L89:
        sub     rsp, 8
        mov     edx, 32
        call    runtime.memequal
        add     rsp, 8
        ret
.L91:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L89
main._627_7string..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L104
.L102:
        push    r12
        mov     r12, rdi
        push    rbp
        mov     rbp, rsi
        push    rbx
        xor     ebx, ebx
        jmp     .L95
.L106:
        cmp     rdi, rsi
        je      .L97
        call    memcmp
        test    eax, eax
        jne     .L93
.L97:
        add     rbx, 16
        cmp     rbx, 432
        je      .L105
.L95:
        movdqu  xmm0, XMMWORD PTR [r12+rbx]
        mov     rdi, QWORD PTR [r12+rbx]
        movdqu  xmm0, XMMWORD PTR [rbp+0+rbx]
        mov     rsi, QWORD PTR [rbp+0+rbx]
        mov     rdx, QWORD PTR [rbp+8+rbx]
        cmp     rdx, QWORD PTR [r12+8+rbx]
        je      .L106
.L93:
        xor     eax, eax
        pop     rbx
        pop     rbp
        pop     r12
        ret
.L105:
        mov     eax, 1
        pop     rbx
        pop     rbp
        pop     r12
        ret
.L104:
        mov     r10d, 24
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L102
main._61024_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L110
.L108:
        sub     rsp, 8
        mov     edx, 1024
        call    runtime.memequal
        add     rsp, 8
        ret
.L110:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L108
main._62_7int32..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L114
.L112:
        sub     rsp, 8
        mov     edx, 8
        call    runtime.memequal
        add     rsp, 8
        ret
.L114:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L112
main._664_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L118
.L116:
        sub     rsp, 8
        mov     edx, 64
        call    runtime.memequal
        add     rsp, 8
        ret
.L118:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L116
main._6256_7uint8..eq:
        cmp     rsp, QWORD PTR fs:112
        jb      .L122
.L120:
        sub     rsp, 8
        mov     edx, 256
        call    runtime.memequal
        add     rsp, 8
        ret
.L122:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L120
main.mul:
        cmp     rsp, QWORD PTR fs:112
        jb      .L125
.L124:
        mov     rax, rdi
        imul    rax, rsi
        ret
.L125:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L124
main.main:
        cmp     rsp, QWORD PTR fs:112
        jb      .L128
        ret
.L128:
        xor     r10d, r10d
        xor     r11d, r11d
        call    __morestack
        ret
        ret
__go_init_main:
        cmp     rsp, QWORD PTR fs:112
        jb      .L132
.L130:
        sub     rsp, 8
        mov     esi, OFFSET FLAT:go..typelists
        mov     edi, 11
        call    runtime.registerTypeDescriptors
        call    internal_1cpu..import
        call    runtime..import
        add     rsp, 8
        ret
.L132:
        mov     r10d, 8
        xor     r11d, r11d
        call    __morestack
        ret
        jmp     .L130
go..typelists:
        .quad   internal_1cpu..types
        .quad   runtime..types
        .quad   internal_1abi..types
        .quad   internal_1bytealg..types
        .quad   internal_1goarch..types
        .quad   internal_1goexperiment..types
        .quad   internal_1goos..types
        .quad   runtime_1internal_1atomic..types
        .quad   runtime_1internal_1math..types
        .quad   runtime_1internal_1sys..types
        .quad   main..types
main..types:
        .zero   16
main._6256_7uint8..eq..f:
        .quad   main._6256_7uint8..eq
main._664_7uint8..eq..f:
        .quad   main._664_7uint8..eq
main._62_7int32..eq..f:
        .quad   main._62_7int32..eq
main._61024_7uint8..eq..f:
        .quad   main._61024_7uint8..eq
main._627_7string..eq..f:
        .quad   main._627_7string..eq
main._632_7uint8..eq..f:
        .quad   main._632_7uint8..eq
main._6129_7uint8..eq..f:
        .quad   main._6129_7uint8..eq
main._6249_7uint8..eq..f:
        .quad   main._6249_7uint8..eq
main._6512_7uint8..eq..f:
        .quad   main._6512_7uint8..eq
main._65_7uint..eq..f:
        .quad   main._65_7uint..eq
main._64_7uintptr..eq..f:
        .quad   main._64_7uintptr..eq
main._665_7uint32..eq..f:
        .quad   main._665_7uint32..eq
main._633_7float64..eq..f:
        .quad   main._633_7float64..eq
main._668_7uint16..eq..f:
        .quad   main._668_7uint16..eq
main._64096_7uint8..eq..f:
        .quad   main._64096_7uint8..eq
main._6128_7uint8..eq..f:
        .quad   main._6128_7uint8..eq
main._68_7uint64..eq..f:
        .quad   main._68_7uint64..eq
main._6122_7uintptr..eq..f:
        .quad   main._6122_7uintptr..eq
main.struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq..f:
        .quad   main.struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq
main._661_7struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq..f:
        .quad   main._661_7struct_4Size_buint32_cMallocs_buint64_cFrees_buint64_5..eq
main._6256_7uint64..eq..f:
        .quad   main._6256_7uint64..eq
main._632_7uintptr..eq..f:
        .quad   main._632_7uintptr..eq
main.struct_4runtime_0gList_cruntime_0n_bint32_5..eq..f:
        .quad   main.struct_4runtime_0gList_cruntime_0n_bint32_5..eq

人们从上述，可以自行看出很多门道来了；没有严格的从目标平台CPU机器汇编代码执行来判断某个编程语言编译代码的执行效率是没有意义的。

liulilittle
关注
专栏目录
基于LLVM的编译原理简明教程: 写一个自己的编译器​
程序员光剑
09-29 1万+
LLVM简介进入21世纪，新的编程语言如雨后春笋一样不停地冒出来。需求当然是重要的驱动力量，但是在其中起了重要作用的就是工具链的改善。2000年，UIUC的Chris Lattner主持开...
VS Code 的 C/C++ 环境变量及编译文件设置集合（避坑指南）
SQX2022的博客
01-01 968
VS Code 的 C/C++ 环境变量及编译文件设置集合 （来自一个纯小白得小小建议） 欢迎使用Markdown编辑器## 标题 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作
编译器将除变成乘法原理
qianmengfusheng的博客
01-10 905
除法运算运算效率在四种基本运算中最慢，是乘法的20倍左右 所以在被除数为固定值时(重要),编译器会把除法优化乘法。 设代码 a/b = c b是常量 设 b*k = 2^n 2的n次直接用移位运算即可 a *2^n/ (b*2 ^n) = c a * b *k/b = c* 2...
【小白打造编译器系列3】实现简单的公式计算器（加法和乘法）（JAVA实现）
见见大魔王
03-26 1382
我们在前文【小白打造编译器系列1】编译器的前端技术是什么？已经知道语法分析的结果是生成一个 AST。那么我们通过实现一个简单的公式计算器来加深对生成 AST 过程的理解。本文的重点是：递归下降算法 和 上下文无关文法。我们简单的计算器这里只考虑 加法 和 乘法。（减法和除法原理上是一样的，这里就不重复完成了） 变量声明语句 我们先来看看变量声明语句，理解什么是“下降”。 之前提到过了，对于 ...
简单编译器的实现 (二) 加入乘法
weixin_30247307的博客
12-13 148
令产生式为 S->T=E; E->T{+T}; T->F{*F}, F->i; 代码如下 很垃圾的代码 乱写的 仅仅做个示范 很多东西要改 呵呵 把a = a + 10 + b * 10 * 3 + c ;编译成"T0=a+10; T1=b*10; T2=T1*3; T3=T0+T2; T4=T3+c; a=T4; " 减法 除...
逆向-beginners之乘法（位移实现）
xiaozhi
09-18 913
逆向-beginners之乘法（位移实现）
C++函数的定义和调用，简单实现加法、乘法运算
weixin_63236032的博客
09-20 1395
【代码】C++函数的定义和调用，简单实现加法、乘法运算。
.NET Framework 4.5 离线安装包 完整版 NDP451-KB2858728-x86-x64
09-01
8. **多语言支持**：.NET Framework 4.5支持C#、VB.NET、F#和C++/CLI等多种编程语言，且在语言特性上都有所增强。 9. **调试和诊断工具**：改进的调试器和性能分析工具帮助开发者更好地理解和优化代码。 10. **...
dotNetFx40-Full-x86-x64
最新发布
04-18
这是一个由微软开发的运行时环境，允许开发者创建Windows应用程序，尤其是使用C#、VB.NET或F#等编程语言的程序。 描述中的内容简洁，没有提供额外的信息，但我们可以推测这是为了安装.NET Framework 4而提供的下载...
微软运行库X86-x64微软运行库.zip
07-12
它包含一组类库，可以支持多种编程语言，如C#、VB.NET、F#等。.NET Framework还提供了CLR（Common Language Runtime），它是.NET应用程序的基础，负责内存管理、安全性和类型检查。 3. **Windows Installer**：这是...
简明x86汇编语言教程
希望我的程序人生一路彪悍
05-26 3634
简明x86汇编语言教程第○章 写在前面 我不想夸大或者贬低汇编语言。但我想说，汇编语言改变了20世纪的历史。与前辈相比，我们这一代编程人员足够的幸福，因为我们有各式各样的编程语言，我们可以操作键盘、坐在显示器面前，甚至使用鼠标、语音识别。我们可以使用键盘、鼠标来驾驭“个人计算机”，而不是和一群人共享一台使用笨重的继电器、开关去操作的巨型机。相比之下，我们的前辈不得不使用机器语言
汇编语言-中括号-mov指令-cmp指令-lea指令
插件开发
10-03 3585
一个比较特别的指令是lea, 意思是"装入有效地址"(Load Effective Address), 它的操作数就是地址,所以lea eax,[edx-02]，就是把 edx 中的值减去2再送入eax, 而不是把由[edx-02]指明的内存地址上的值放到eax. 其结果是[eax]和[ebx-02]都表示同一个地址。1、mov [edi], eax ----把eax的值(dword)赋给位于内存地址edi处的值。10、mov cx,[eax]–把位于内存地址eax的word大小的值移入cx寄存器。
【逆向】汇编相关知识
一个努力生活的人的博客
03-18 2364
汇编
【逆向入门】 CrackMe160-005 分析思路
mastergu2的博客
05-05 489
CrackMe160-005 这道题难度严重超标了。。纯小白的我呕心沥血才算勉强搞明白了，并且也学到不少东西，不多说废话，来看题 爆破思路 养成好习惯，爆破流程第一步，用exeinfo打开看看文件是否加壳并且使用的什么语言 可以看出有UPX的壳，那么我们直接使用UPX脱壳软件就可以产生一个新的，已经脱壳完成的exe了，原来的exe已经在后面加上了.bak后缀，已经是备份文件了，这里我们打开生成的exe 这诡异的三字经，阴间的黑白配色，名字里的层层设防。。。一切看起来都那么“和蔼” 既然直接爆破的话，
X86汇编学习小结----cmp 完整版本
热门推荐
JK198310的专栏
09-17 1万+
生成汇编代码 比如，一个简单的函数： // hello.c void func(){} 如何得到相应的汇编代码呢？ gcc -S hello.c hello.s clang -S hello.c hello.s gcc -S -masm=intel hello.c
unity c#脚本_爆发！ 如何在Unity C＃脚本中停止无限循环
culiao6493的博客
09-07 1454
unity c#脚本(or what I did at my first Hack Week with Unity) (或者我在Unity的第一个Hack Week所做的事情) 这篇文章是关于打破Unity中脚本无限循环的小技巧。 它可以在Windows / 64位编辑器中使用，也可以在64位版本中启用脚本调试。 稍加努力，就可以在32位上运行，甚至可以在禁用脚本调试的情况下进行构建。 (T...
滴水三期：day31.1-代码节空白区添加代码
Edimade的博客
05-02 1195
一、代码节空白区添加代码（1.MessageBox函数说明>2.call与jmp指令的硬编码>3.添加代码效果说明>4.添加思路）>二、作业（1.在代码空白区添加代码(手动)）
转一篇汇编语言的好文
snowpiaop的专栏
06-29 1184
nasm assembly 语法 3.1 nasm 是匹分大小写 3.2 内存操作数表达式 3.2.1 在 nasm 语法里，对 memory 操作数需要加 [] 括号 3.2.2 给 memory 操作数提供一个 displacement 值 3.2.3 指明 memory 操作数的 operand size 3.2.4 提供一个 segment 3.2.5 指明 memory 操作数
VS Code配置C/C++环境解决#include错误（POSIX API）
"VS Code C/C++环境配置教程主要针对在使用VS Code进行C/C++编程时遇到的‘无法打开源文件“xxxxxx.h”’或‘#include错误’问题，通过更新includePath来解决。教程特别提到了POSIX API的背景，并在Windows环境下为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值