05|计算机指令

计算机指令集 instruction set
Intel ARM 架构

常见的五大类指令

  1. 算数类指令
  2. 数据传输类指令
  3. 逻辑类指令
  4. 条件分支指令
  5. 无条件跳转指令

极客时间计算机组成原理专栏笔记（二） - 图1

  1. 打开win10 上的ubutun
  2. sudo apt-get install build-essential 安装 gcc
  3. gcc —version
  4. vim test.c
  5. gcc -g -c test.c
  6. $ objdump -d -M intel -S test.o

06|指令跳转

CPU是如何执行指令的？

  1. PC寄存器（program counter register）/指令地址寄存器（instruction address register）
    用来存放下一条需要处理执行的计算机指令的内存地址。
  2. 指令寄存器（instruction register），存放当前正在执行的指令
  3. 条件码寄存器（status register ），用里面的一个一个标记位，存放 CPU进行算数或者逻辑计算的结果
  4. 通用寄存器，存放数据，地址等，比如整数寄存器，浮点数寄存器，向量寄存器，地址寄存器等

一个程序执行的时候，CPU会根据PC寄存器中的地址，把内存中需要执行的指令读取到指令寄存器里面执行，然后根据指令长度自增，开始顺序读取下一条指令。跳转指令，会修改PC寄存器里面的地址值。

SwitchCase 汇编

  1. paradise@PradiseXPS:~$ cat switch.c
  2. #include <stdio.h>
  4. int main()
  5. {
  6.         int a = 3;
  7.         int x = 0;
  8.         switch(a)
  9.         {
  10.                 case 0:
  11.                         a = 0;
  12.                         break;
  13.                 case 1:
  14.                         a = 1;
  15.                         break;
  16.                 case 2:
  17.                         a = 2;
  18.                         break;
  19.                 case 3:
  20.                         a = 3;
  21.                         break;
  22.                 case 4:
  23.                         a = 4;
  24.                         break;
  25.                 case 5:
  26.                         a = 5;
  27.                         break;
  28.                 case 6:
  29.                         a = 6;
  30.                         break;
  31.                 default:
  32.                         a = 0;
  34.         }
  35.         return 0;
  36. }
  37. paradise@PradiseXPS:~$ gcc -g -c switch.c
  38. paradise@PradiseXPS:~$ ls
  39. print.c  print.o  switch.c  switch.o  test.c  test.o
  40. paradise@PradiseXPS:~$ objdump -d -M intel -S switch.o
  42. switch.o:     file format elf64-x86-64
  45. Disassembly of section .text:
  47. 0000000000000000 <main>:
  48. #include <stdio.h>
  50. int main()
  51. {
  52.    0:   55                      push   rbp
  53.    1:   48 89 e5                mov    rbp,rsp
  54.         int a = 3;
  55.    4:   c7 45 f8 03 00 00 00    mov    DWORD PTR [rbp-0x8],0x3
  56.         int x = 0;
  57.    b:   c7 45 fc 00 00 00 00    mov    DWORD PTR [rbp-0x4],0x0
  58.         switch(a)
  59.   12:   83 7d f8 06             cmp    DWORD PTR [rbp-0x8],0x6
  60.   16:   77 63                   ja     7b <main+0x7b>
  61.   18:   8b 45 f8                mov    eax,DWORD PTR [rbp-0x8]
  62.   1b:   48 8d 14 85 00 00 00    lea    rdx,[rax*4+0x0]
  63.   22:   00
  64.   23:   48 8d 05 00 00 00 00    lea    rax,[rip+0x0]        # 2a <main+0x2a>
  65.   2a:   8b 04 02                mov    eax,DWORD PTR [rdx+rax*1]
  66.   2d:   48 63 d0                movsxd rdx,eax
  67.   30:   48 8d 05 00 00 00 00    lea    rax,[rip+0x0]        # 37 <main+0x37>
  68.   37:   48 01 d0                add    rax,rdx
  69.   3a:   ff e0                   jmp    rax
  70.         {
  71.                 case 0:
  72.                         a = 0;
  73.   3c:   c7 45 f8 00 00 00 00    mov    DWORD PTR [rbp-0x8],0x0
  74.                         break;
  75.   43:   eb 3d                   jmp    82 <main+0x82>
  76.                 case 1:
  77.                         a = 1;
  78.   45:   c7 45 f8 01 00 00 00    mov    DWORD PTR [rbp-0x8],0x1
  79.                         break;
  80.   4c:   eb 34                   jmp    82 <main+0x82>
  81.                 case 2:
  82.                         a = 2;
  83.   4e:   c7 45 f8 02 00 00 00    mov    DWORD PTR [rbp-0x8],0x2
  84.                         break;
  85.   55:   eb 2b                   jmp    82 <main+0x82>
  86.                 case 3:
  87.                         a = 3;
  88.   57:   c7 45 f8 03 00 00 00    mov    DWORD PTR [rbp-0x8],0x3
  89.                         break;
  90.   5e:   eb 22                   jmp    82 <main+0x82>
  91.                 case 4:
  92.                         a = 4;
  93.   60:   c7 45 f8 04 00 00 00    mov    DWORD PTR [rbp-0x8],0x4
  94.                         break;
  95.   67:   eb 19                   jmp    82 <main+0x82>
  96.                 case 5:
  97.                         a = 5;
  98.   69:   c7 45 f8 05 00 00 00    mov    DWORD PTR [rbp-0x8],0x5
  99.                         break;
  100.   70:   eb 10                   jmp    82 <main+0x82>
  101.                 case 6:
  102.                         a = 6;
  103.   72:   c7 45 f8 06 00 00 00    mov    DWORD PTR [rbp-0x8],0x6
  104.                         break;
  105.   79:   eb 07                   jmp    82 <main+0x82>
  106.                 default:
  107.                         a = 0;
  108.   7b:   c7 45 f8 00 00 00 00    mov    DWORD PTR [rbp-0x8],0x0
  110.         }
  111.         return 0;
  112.   82:   b8 00 00 00 00          mov    eax,0x0
  113. }
  114.   87:   5d                      pop    rbp
  115.   88:   c3                      ret
  116. paradise@PradiseXPS:~$

补充内容

  1. paradise@PradiseXPS:~$ objdump -H
  2. Usage: objdump <option(s)> <file(s)>
  3.  Display information from object <file(s)>.
  4.  At least one of the following switches must be given:
  5.   -a, --archive-headers    Display archive header information
  6.   -f, --file-headers       Display the contents of the overall file header
  7.   -p, --private-headers    Display object format specific file header contents
  8.   -P, --private=OPT,OPT... Display object format specific contents
  9.   -h, --[section-]headers  Display the contents of the section headers
  10.   -x, --all-headers        Display the contents of all headers
  11.   -d, --disassemble        Display assembler contents of executable sections
  12.   -D, --disassemble-all    Display assembler contents of all sections
  13.   -S, --source             Intermix source code with disassembly
  14.   -s, --full-contents      Display the full contents of all sections requested
  15.   -g, --debugging          Display debug information in object file
  16.   -e, --debugging-tags     Display debug information using ctags style
  17.   -G, --stabs              Display (in raw form) any STABS info in the file
  18.   -W[lLiaprmfFsoRtUuTgAckK] or
  19.   --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,
  20.           =frames-interp,=str,=loc,=Ranges,=pubtypes,
  21.           =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,
  22.           =addr,=cu_index,=links,=follow-links]
  23.                            Display DWARF info in the file
  24.   -t, --syms               Display the contents of the symbol table(s)
  25.   -T, --dynamic-syms       Display the contents of the dynamic symbol table
  26.   -r, --reloc              Display the relocation entries in the file
  27.   -R, --dynamic-reloc      Display the dynamic relocation entries in the file
  28.   @<file>                  Read options from <file>
  29.   -v, --version            Display this program's version number
  30.   -i, --info               List object formats and architectures supported
  31.   -H, --help               Display this information
  33.  The following switches are optional:
  34.   -b, --target=BFDNAME           Specify the target object format as BFDNAME
  35.   -m, --architecture=MACHINE     Specify the target architecture as MACHINE
  36.   -j, --section=NAME             Only display information for section NAME
  37.   -M, --disassembler-options=OPT Pass text OPT on to the disassembler
  38.   -EB --endian=big               Assume big endian format when disassembling
  39.   -EL --endian=little            Assume little endian format when disassembling
  40.       --file-start-context       Include context from start of file (with -S)
  41.   -I, --include=DIR              Add DIR to search list for source files
  42.   -l, --line-numbers             Include line numbers and filenames in output
  43.   -F, --file-offsets             Include file offsets when displaying information
  44.   -C, --demangle[=STYLE]         Decode mangled/processed symbol names
  45.                                   The STYLE, if specified, can be `auto', `gnu',
  46.                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'
  47.                                   or `gnat'
  48.   -w, --wide                     Format output for more than 80 columns
  49.   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling
  50.       --start-address=ADDR       Only process data whose address is >= ADDR
  51.       --stop-address=ADDR        Only process data whose address is <= ADDR
  52.       --prefix-addresses         Print complete address alongside disassembly
  53.       --[no-]show-raw-insn       Display hex alongside symbolic disassembly
  54.       --insn-width=WIDTH         Display WIDTH bytes on a single line for -d
  55.       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses
  56.       --special-syms             Include special symbols in symbol dumps
  57.       --inlines                  Print all inlines for source line (with -l)
  58.       --prefix=PREFIX            Add PREFIX to absolute paths for -S
  59.       --prefix-strip=LEVEL       Strip initial directory names for -S
  60.       --dwarf-depth=N        Do not display DIEs at depth N or greater
  61.       --dwarf-start=N        Display DIEs starting with N, at the same depth
  62.                              or deeper
  63.       --dwarf-check          Make additional dwarf internal consistency checks.
  65. objdump: supported targets: elf64-x86-64 elf32-i386 elf32-iamcu elf32-x86-64 a.out-i386-linux pei-i386 pei-x86-64 elf64-l1om elf64-k1om elf64-little elf64-big elf32-little elf32-big pe-x86-64 pe-bigobj-x86-64 pe-i386 plugin srec symbolsrec verilog tekhex binary ihex
  66. objdump: supported architectures: i386 i386:x86-64 i386:x64-32 i8086 i386:intel i386:x86-64:intel i386:x64-32:intel i386:nacl i386:x86-64:nacl i386:x64-32:nacl iamcu iamcu:intel l1om l1om:intel k1om k1om:intel plugin
  68. The following i386/x86-64 specific disassembler options are supported for use
  69. with the -M switch (multiple options should be separated by commas):
  70.   x86-64      Disassemble in 64bit mode
  71.   i386        Disassemble in 32bit mode
  72.   i8086       Disassemble in 16bit mode
  73.   att         Display instruction in AT&T syntax
  74.   intel       Display instruction in Intel syntax
  75.   att-mnemonic
  76.               Display instruction in AT&T mnemonic
  77.   intel-mnemonic
  78.               Display instruction in Intel mnemonic
  79.   addr64      Assume 64bit address size
  80.   addr32      Assume 32bit address size
  81.   addr16      Assume 16bit address size
  82.   data32      Assume 32bit data size
  83.   data16      Assume 16bit data size
  84.   suffix      Always display instruction suffix in AT&T syntax
  85.   amd64       Display instruction in AMD64 ISA
  86.   intel64     Display instruction in Intel64 ISA
  87. Report bugs to <http://www.sourceware.org/bugzilla/>.
  88. paradise@PradiseXPS:~$

07|函数调用

StackOverflow 栈溢出

函数调用示例程序

  1. paradise@PradiseXPS:~$ cat example.c
  2. // function_example.c
  3. #include <stdio.h>
  5. int static add(int a,int b)
  6. {
  7.         return a + b;
  8. }
  10. int main()
  11. {
  12.         int x = 5;
  13.         int y = 10;
  14.         int u = add(x,y);
  15. }
  17. paradise@PradiseXPS:~$ objdump -d -M intel -S example.o
  19. example.o:     file format elf64-x86-64
  22. Disassembly of section .text:
  24. 0000000000000000 <add>:
  25. // function_example.c
  26. #include <stdio.h>
  28. int static add(int a,int b)
  29. {
  30.    0:   55                      push   rbp
  31.    1:   48 89 e5                mov    rbp,rsp
  32.    4:   89 7d fc                mov    DWORD PTR [rbp-0x4],edi
  33.    7:   89 75 f8                mov    DWORD PTR [rbp-0x8],esi
  34.         return a + b;
  35.    a:   8b 55 fc                mov    edx,DWORD PTR [rbp-0x4]
  36.    d:   8b 45 f8                mov    eax,DWORD PTR [rbp-0x8]
  37.   10:   01 d0                   add    eax,edx
  38. }
  39.   12:   5d                      pop    rbp
  40.   13:   c3                      ret
  42. 0000000000000014 <main>:
  44. int main()
  45. {
  46.   14:   55                      push   rbp
  47.   15:   48 89 e5                mov    rbp,rsp
  48.   18:   48 83 ec 10             sub    rsp,0x10
  49.         int x = 5;
  50.   1c:   c7 45 f4 05 00 00 00    mov    DWORD PTR [rbp-0xc],0x5
  51.         int y = 10;
  52.   23:   c7 45 f8 0a 00 00 00    mov    DWORD PTR [rbp-0x8],0xa
  53.         int u = add(x,y);
  54.   2a:   8b 55 f8                mov    edx,DWORD PTR [rbp-0x8]
  55.   2d:   8b 45 f4                mov    eax,DWORD PTR [rbp-0xc]
  56.   30:   89 d6                   mov    esi,edx
  57.   32:   89 c7                   mov    edi,eax
  58.   34:   e8 c7 ff ff ff          call   0 <add>
  59.   39:   89 45 fc                mov    DWORD PTR [rbp-0x4],eax
  60.   3c:   b8 00 00 00 00          mov    eax,0x0
  61. }
  62.   41:   c9                      leave
  63.   42:   c3                      ret
  64. paradise@PradiseXPS:~$

call 指令后面跟着的，仍然是跳转后的程序地址；

add函数

函数开始执行了 一条push指令和一条mov指令
函数结束的时候执行了一条pop和一条ret指令
这四条指令的执行其实就是压栈和出栈的操作。

函数调用和条件跳转不同之处在于，执行了内存地址的跳转指令之后，还需要再回来继续执行。
在内存中开辟一段空间，用 栈这个 LIFO后进先出的数据结构。

栈帧 stack frame 整个函数A的所占用的所有的内存空间，就是函数A的栈帧；

push rbp 把之前调用函数，也就是main函数的栈帧的栈底地址，压到栈顶。
mov rbp,rsp 把rsp这个栈指针的值复制到到rbp里，而rsp始终会指向栈顶

rbp - register base pointer (start of stack) 栈帧指针，存放了当前栈帧位置的寄存器
rsp - register stack pointer (current location in stack, growing downwards) 栈指针

小结

学的云里雾里的，有点懵逼了。
这里需要有时间回过头来，回顾下汇编的知识。

08|ELF和静态链接

objdump命令

可执行文件 executale program
目标文件 object file
链接器 linker

通过 gcc -o 参数，可以生成对应的可执行文件

“c语言代码 - 汇编代码 - 机器码”

  1. 编译compile 汇编 assemble 链接 link
  2. 通过装载器loader把可执行文件装载load到内存中，CPU从内存中读取指令和数据，开始执行程序。

image.png

ELF格式和链接：理解链接过程

ELF executable and linkable file format 可执行与可链接文件格式

如果我们有一个能够解析PE格式的装载器，我们就有可能在linux下运行windows程序了。Wine
WSL windows subsystem for linux ，可以解析家在ELF格式的文件

课后思考：

readelf 读取程序的符号表
objdump 读取重定位表

09|程序装载

把程序装载到内存：

  1. 可执行程序加载后占用的内存空间应该是连续的
  2. 我们需要同时加载很多个程序，并且不能让程序自己规定在内存中加载的位置

内存分段 segmentation

内存碎片 memory fragmentation
内存交换 memory swapping

内存分页

课后思考：JAVA程序是如何装载到内存里面的？

10|动态链接

动态链接 dynamic link
静态链接 static link
共享库 shared libraries

dll dynamic-link-library
so shared object

相对地址 relative address

程序链接表 procedure link table
全局偏移表 GOT global offset table
虽然共享库的代码部分的物理内存是共享的，但是数据部分是各个动态链接它的应用

课后思考

节省内存空间

11|二进制编码

整数，二进制与十六进制转化
负数

原码

补码

ASCII码：用8位二进制中的128个不同的数，映射到128个不同的字符串。

存储数据的时候，要采用二进制序列化的方式，不管是整数也好，浮点数也好，采用二进制序列化会比存储文本省下不少空间。

字符集 charset
字符编码 character encoding

UTF

手持两把锟斤拷，口中疾呼烫烫烫
脚踏千朵屯屯屯，笑看万物锘锘锘

12|理解电路

信息传播的历史
继电器 relay
反向器 inverter

13|加法器

14|乘法器

15|浮点数和定点数