1. 浮点寄存器
2. 浮点数指令 - 传送和转换操作
3. 浮点数指令 - 寄存器分配
4. 浮点数指令 - 浮点数的运算和浮点常数
5. 浮点数指令 - 浮点数的位级操作
6. 浮点数指令 - 浮点数比较

浮点寄存器

浮点数指令 - 传送和转换操作

1. vmovss, 从寄存器和内存之间互相传送一个单精度数
2. vmovsd, 从寄存器和内存之间互相传送一个双精度数
3. vomvaps, 在寄存器之间互相传送对齐的单精度数
4. vomvapd, 在寄存器之间传送对齐的双精度数

1. vcvttss2si X/M32 R32, 单精度转32位整数
2. vcvttsd2si X/M64 R32, 双精度转32位整数
3. vcvttss2siq X/M32 R64, 单精度转64位整数
4. vcvttsd2siq X/M64 R64, 双精度转64位整数

1. vcvtsi2ss M32/R32 X X, 把32位整数转换为单精度浮点
2. vcvtsi2sd M32/R32 X X, 把32位整数转换为双精度浮点
3. vcvtsi2ssq M64/R64 X X, 把64位整数转换为单精度浮点
4. vcvtsi2sdq M64/R64 X X, 把64位整数转换为双精度浮点

练习 3.50 确定代码中的对应关系

double fcvt2(int *ip, float *fp, double *dp, long l) {
    int i = *ip;
    float f = *fp;
    double d = *dp;
    *ip = (int)     val1;
    *fp = (float)   val2;
    *dp = (double)  val3;
    return (double) val4;
}

double fcvt2(int *ip, float *fp, double *dp, long l)
ip in %rdi, fp in %rsi, dp in %rdx, l in %rcx
fcvt2:
    movl        (%rdi), %eax        把i的值放入%eax
    vmovss      (%rsi), %xmm0       传送单精度数, 把f 放入%xmm0
    vcvttsd2si  (%rdx), %r8d        这个指令是双精度转32位整数, 放入 %r8d, 注意, 转换成int的只有 val1, 所以val1 就是 d
    movl        %r8d, (%rdi)        将转换后的int值写入到ip对应的内存位置, 结合上一句, 很显然 val1 确实就是 d
    vcvtsi2ss   %eax, %xmm1, %xmm1  转换32位整数为单精度浮点, %eax中是i, 结合程序代码看, 转换为float的只有 val2, 也就是 i
    vmovss      %xmm1, (%rsi)       将转换后的单精度数写入fp对应的地址, 显然 val2 = i
    vcvtsi2sdq  %rcx, %xmm1, %xmm1  这是把64位整数转换为双精度浮点, 注意%rcx 中是l,所以这个是转换的l, 要看写入到哪里才能确定
    vmovsd      %xmm1, (%rdx)       把转换后的l写入到dp对应的地址, 所以val3 = l
    vunpcklps   %xmm0, %xmm0, %xmm0 把单精度的f准备转换成双精度
    vcvtps2pd   %xmm0, %xmm0        和上一句一起看, 是将f转换为双精度浮点
    ret                             最后返回, 则很显然, val4 = f

1. val1 = d
2. val2 = i
3. val3 = l
4. val4 = f

练习 3.51 写出转换指令

dest_t cvt(src_t x){
    dest_t y = (dest_t) x;
    return y;
}

浮点数指令 - 寄存器分配

练习 3.52 确定参数的寄存器分配

1. double g1(double a, long b, float c, int d), 参数分别为浮点, 整型, 浮点, 整型, 寄存器排布为 a in %xmm0, b in %rdi, c in %xmm1, d in %esi
2. double g2(int a, double *b, float *c, long d), 四个参数都是整型或者指针, 所以全部排布在整型寄存器中: a in %edi, b in %rsi, c in %rdx, d in %rcx
3. double g3(double *a, double b, int c, float d), 四个参数是指针, 浮点, int, 浮点, 寄存器排布为: a in %rdi, b in %xmm0, c in %esi, d in %xmm1
4. double g3(float a, int *b, float c, double d), 四个参数是浮点, 指针, 浮点, 浮点, 寄存器排布为: a in %xmm0, b in %rdi, c in %xmm1, d in %xmm2

浮点数指令 - 浮点数的运算和浮点常数

练习 3.53 根据代码确定参数的类型

double funct1(art1_t p, arg2_t q, arg3_t r, arg4_t s){
    return p/(q+r) - s;
}

double funct1(art1_t p, arg2_t q, arg3_t r, arg4_t s)
funct1:
    vcvtsi2ssq      %rsi, %xmm2, %xmm2      把第二个整型寄存器中的四字节整型转换为单精度浮点. 这里从寄存器里能看出来, 使用%rsi, 放入到%xmm2说明有两个整型, 两个浮点
    vaddss          %xmm0, %xmm2, %xmm0     单精度浮点数相加, 这里应该计算的是 q + r , 由此可以判断 %xmm0 是单精度浮点数. 但q和r哪一个是整数转换的, 还不好说
    vcvtsi2ss       %edi, %xmm2, %xmm2      把32位整数转换成单精度浮点, 放在 %xmm2中
    vdivss          %xmm0, %xmm2, %xmm0     用 p/(q+r) 的结果放入%xmm0中, 所以可以知道 p一定是32位整数类型
    vunpcklps       %xmm0, %xmm0, %xmm0
    vcvtps2pd       %xmm0, %xmm0            这两句把p/(q+r)的结果转换成双精度浮点数
    vsubsd          %xmm1, %xmm0, %xmm0     可知%xmm1中的变量是一个双精度浮点数, 可以直接减. 即 s 是双精度浮点数.
    ret

练习 3.54 根据汇编代码写出C代码

double funct2(double w, int x, float y,long z)
w in %xmm0, x in %edi, y in %xmm1, z in %rsi

funct2:
    vcvtsi2ss       %edi, %xmm2, %xmm2      把 x 转换成 float类型, 可以写成 float temp = (float) x
    vmulss          %xmm1, %xmm2, %xmm1     y = y * temp
    vunpcklps       %xmm1, %xmm1, %xmm1
    vcvtps2pd       %xmm1, %xmm2            把单精度 y 转换为双精度 , 存放在 %xmm2中, double temp2 = (double) y
    vcvtsi2sdq      %rsi, %xmm1, %xmm1      把 z 转换为双精度, 放在 %xmm1中 double temp3 = (double) z
    vdivsd          %xmm1, %xmm0, %xmm0     w = w/temp3
    vsudsd          %xmm0, %xmm2, %xmm0     return  y - w/temp3
    ret

double funct2(double w, int x, float y,long z){
    float temp = (float) x;
    y = y * temp;
    double temp2 = (double) y;
    double temp3 = (double) z;
    w = w/temp3;
    return y - w;
}

double funct2(double w, int x, float y,long z){
    return y * x - w / z;
}

double cel2fahr(double temp){
    return 1.8 * temp + 32.0;
}

double cel2fahr(double temp)
temp in %xmm0

cel2fahr:
    //这里的%rip是指令地址寄存器, 不能够直接操作
    vmulsd      .LC2(%rip), %xmm0, %xmm0
    vaddsd      .LC3(%rip), %xmm0, %xmm0
    ret
  .LC2
    .long   3435973837
    .long   1073532108

  .LC3
    .long   0
    .long   1077936128

3    f    f    c    c    c    c    c    c    c    c    c    c    c    c    d
0011 1111 1111 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1100 1101

练习 3.55 浮点常量是如何表示的

4    0    4    0    ......
0100 0000 0100 0000 ......

浮点数指令 - 浮点数的位级操作

练习 3.56 根据汇编补全C代码

double simplefun(double x){
    return EXPR(x);
}

1.             vmovsd      .LC1(%rip), %xmm1
               vandpd      %xmm1, %xmm0, %xmm0
             .LC2:
               .long 4294967295
               .long 2147483647
               .long 0
               .long 0
   

   第一行指令是传送双精度数, 所以要看一下传送了什么东西: LC2中的值实际上是 00000000 00000000 7fffffff ffffffff. 看低64位的话, 这是01111.... 将x和这串数字进行与运算的结果, 实际上就是将x的最高位符号位置0, 其他位不变, 所以这是一个将浮点数x转换成正数或者说是绝对值的过程.

2.             vxorpd  %xmm0, %xmm0, %xmm0
   

   这个是将%xmm与自身进行异或运算, 可以知道, 结果是一串0, 所以这个是将寄存器内的浮点数清理成+0

3.             vmovsd      .LC2(%rip), %xmm1
               vxorpd      %xmm1, %xmm0 ,%xmm0
             .LC2:
               .long 0
               .long -2147483648
               .long 0
               .long 0
   

   这个也需要重新排布LC2看看位级表示: 00000000 00000000 80000000 00000000, 用这个LC2去和 x 进行异或运算, 可以知道 与 0 进行异或, 不改变原来的位. 与1进行异或, 会改变原来的位. 所以这个函数的意义就是返回将第64位也就是最高位取反的功能, 也就是改变double x 的符号位.

浮点数指令 - 浮点数比较

double funct3(int *ap, double b, long c, float *dp)
p in %rdi, b in %xmm0, c in %rsi, dp in %rdx

funct3:
    vmovss      (%rdx), %xmm1           传送单精度到%xmm1中, float temp = *dp
    vcvtsi2sd   (%rdi), %xmm2, %xmm2    转换*ap为双精度数, double temp2 = (double) *ap
    vucomisd    %xmm2, %xmm0            比较 b : temp2
    jbe L8                              b<=temp2的时候跳转L8
    vcvtsi2ssq  %rsi, %xmm0, %xmm0      把 c 转换为单精度数 float temp3 = (float) c
    vmulss      %xmm1, %xmm0, %xmm1     temp = temp * temp3
    vunpcklps   %xmm1, %xmm1, %xmm1
    vcvtps2pd   %xmm1, %xmm0            这两句是将temp的结果转换成double返回
    ret

  .L8:
    vaddss      %xmm1, %xmm1, %xmm1     temp = temp * 2
    vcvtsi2ssq  %rsi, %xmm0, %xmm0      float temp3 = (float) c
    vaddss      %xmm1, %xmm0, %xmm0     temp3 = temp3 + temp
    vunpcklps   %xmm1, %xmm1, %xmm1
    vcvtps2pd   %xmm1, %xmm0            这两句是将temp的结果转换成double返回
    ret

double funct3(int *ap, double b, long c, float *dp){
    if(b<=(*ap)){
        return 2 * (*dp) + c;
    } else {
        return (*dp) * c;
    }
}