Improve floating point

cirosantilli · cirosantilli · commit 063f2c1ec113 · 2015-06-04T09:42:42.000+02:00
diff --git a/bibliography.md b/bibliography.md
@@ -48,5 +48,9 @@
 
     Lots of info on what C code maps to in assembly, and how to look for what matters to reverse engineer stuff.
 
+-   <http://www.agner.org/optimize/>
+
+    Highly regarded optimization guidelines for x86 and C++.
+
 [Itanium C++ ABI]: http://mentorembedded.github.io/cxx-abi/abi.html
 [System V ABI AMD64]: http://www.x86-64.org/documentation_folder/abi-0.99.pdf
diff --git a/compiler-generated/.gitignore b/compiler-generated/.gitignore
@@ -1,3 +1,3 @@
 *.s
-*.o_readelf
-*.out_readelf
+*.readelf
+*.objdump
diff --git a/compiler-generated/Makefile b/compiler-generated/Makefile
@@ -1,14 +1,18 @@
 .POSIX:
 
 ASM_EXT ?= .s
-CCC ?= gcc -pedantic-errors -std=c89 -Wextra
+O ?= 0
+CCC ?= gcc -pedantic-errors -std=c99 -Wextra -ggdb -O$(O)
 CCC_CPP ?= g++ -pedantic-errors -std=c++11 -Wextra
 IN_EXT ?= .c
 IN_EXT_CPP ?= .cpp
+LIBS ?= -lm
 OBJ_EXT ?= .o
 OUT_EXT ?= .out
-OBJ_READELF_EXT ?= .o_readelf
-OUT_READELF_EXT ?= .out_readelf
+OBJ_READELF_EXT ?= $(OBJ_EXT).readelf
+OUT_READELF_EXT ?= $(OUT_EXT).readelf
+OBJ_OBJDUMP_EXT ?= $(OBJ_EXT).objdump
+OUT_OBJDUMP_EXT ?= $(OUT_EXT).objdump
 RUN ?= hello_world
 
 INS := $(wildcard *$(IN_EXT))
@@ -22,18 +26,22 @@ OUTS_CPP := $(addsuffix $(OUT_EXT), $(basename $(INS_CPP)))
 all: $(OUTS) $(OUTS_CPP)
 
 %$(OUT_EXT): %$(IN_EXT)
-	$(CCC) -S '$<' -o '$(basename $@)$(ASM_EXT)'
-	$(CCC) -c '$(basename $@)$(ASM_EXT)' -o '$(basename $@)$(OBJ_EXT)'
-	$(CCC) '$(basename $@)$(OBJ_EXT)' -o '$@'
-	readelf -a '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_READELF_EXT)'
-	readelf -a '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_READELF_EXT)'
+	$(CCC) -S '$<' -o '$(basename $@)$(ASM_EXT)' $(LIBS)
+	$(CCC) -c '$(basename $@)$(ASM_EXT)' -o '$(basename $@)$(OBJ_EXT)' $(LIBS)
+	readelf -W -a '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_READELF_EXT)'
+	objdump -S    '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_OBJDUMP_EXT)'
+	$(CCC) '$(basename $@)$(OBJ_EXT)' -o '$@' $(LIBS)
+	readelf -W -a '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_READELF_EXT)'
+	objdump -S    '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_OBJDUMP_EXT)'
 
 %$(OUT_EXT): %$(IN_EXT_CPP)
 	$(CCC_CPP) -S '$<' -o '$(basename $@)$(ASM_EXT)'
 	$(CCC_CPP) -c '$(basename $@)$(ASM_EXT)' -o '$(basename $@)$(OBJ_EXT)'
+	readelf -W -a '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_READELF_EXT)'
+	objdump -S    '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_OBJDUMP_EXT)'
 	$(CCC_CPP) '$(basename $@)$(OBJ_EXT)' -o '$@'
-	readelf -a '$(basename $@)$(OBJ_EXT)' > '$(basename $@)$(OBJ_READELF_EXT)'
-	readelf -a '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_READELF_EXT)'
+	readelf -W -a '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_READELF_EXT)'
+	objdump -S    '$(basename $@)$(OUT_EXT)' > '$(basename $@)$(OUT_OBJDUMP_EXT)'
 
 clean:
 	rm -f  *'$(ASM_EXT)' *'$(OBJ_EXT)' *'$(OUT_EXT)' *'$(OBJ_READELF_EXT)' *'$(OUT_READELF_EXT)'
diff --git a/compiler-generated/README.md b/compiler-generated/README.md
@@ -10,6 +10,12 @@ Let's see what our compilers are compiling to.
     1. [common.c](common.c)
     1. [data.c](data.c)
 1.  [hello_world.c](hello_world.c)
-1.  [function.c](function.c)
+1.  [function_int_int_int.c](function_int_int_int.c)
+1.  Floating point
+    [float_sum.c](float_sum.c)
+    [float2int.c](float2int.c)
+    [sqrt.c](sqrt.c)
+1.  Optimization
+    1. [use_rax_return.c](use_rax_return.c)
 1.  libc
     1. [memcmp.c](memcmp.c)
diff --git a/compiler-generated/a b/compiler-generated/a
@@ -0,0 +1,28 @@
+ 1, 3, 4, 5, 13, 2, 3, 4, 22, 1, 2, 3 
+1
+4
+6
+28
+30 1, 3, 4, 5, 13, 2, 3, 4, 22, 1, 2, 3 
+1
+4
+6
+28
+301, 2, 2, 4, 8, 1, 8, 1⁄2, 4, 1, 4, 4  
+1
+4
+8
+12
+16
+9, 3, 6, 21, 9, 12, 33, 15, 18  11.6, 2.3, 9.7, 11.3, 2.1, 9.6, 11, 1.9, 9.5 
+10.4
+10.7
+10.8
+11.3
+11.9
+ 5, 6, 11, 2, 9, 3, 12, 6, 6, 3 
+3
+6
+9
+15
+18
diff --git a/compiler-generated/double_sum.c b/compiler-generated/double_sum.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    double f;
+    f = (double)(time(NULL) % 3);
+    /*
+    GCC 4.8:
+
+    - fpmath=sse: addsd (default)
+    */
+    f += 0.5;
+    printf("%f\n", f);
+    return 0;
+}
diff --git a/compiler-generated/float2int.c b/compiler-generated/float2int.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    int i;
+    float f;
+    f = (float)(time(NULL) % 3) + 0.5;
+    /*
+    - sse: cvttss2si
+    */
+    i = (int)f;
+    printf("%d\n", i);
+    return 0;
+}
diff --git a/compiler-generated/float2int_direct_vs_variable.c b/compiler-generated/float2int_direct_vs_variable.c
@@ -0,0 +1,27 @@
+/*
+http://stackoverflow.com/questions/17220787/c-casting-from-double-to-int
+
+Don't reproduce him.
+*/
+
+#include <stdio.h>
+#include <stdarg.h>
+
+int main() {
+    int a;
+    int d;
+    double b = 0.41;
+
+    /* Cast from variable. */
+    double c = b * 100.0;
+    a = (int)(c);
+
+    /* Cast expression directly. */
+    d = (int)(b * 100.0);
+
+    printf("c = %f \n", c);
+    printf("a = %d \n", a);
+    printf("d = %d \n", d);
+
+    return 0;
+}
diff --git a/compiler-generated/float_sum.c b/compiler-generated/float_sum.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    float f;
+    f = (float)(time(NULL) % 3);
+    /*
+    GCC 4.8:
+
+    - fpmath=sse: addss (default)
+    - fpmath=fpu: faddp
+    */
+    f += 0.5f;
+    printf("%f\n", f);
+    return 0;
+}
diff --git a/compiler-generated/function.c b/compiler-generated/function.c
diff --git a/compiler-generated/function_int_int_int.c b/compiler-generated/function_int_int_int.c
@@ -0,0 +1,20 @@
+/* Simple function that takes two ints and returns a third. */
+
+#include <stdio.h>
+
+/*
+GCC 4.8 -O3 reduces this to a single lea.
+*/
+int my_function(int i, int j) {
+    int k;
+    k = i + j;
+    return k;
+}
+
+int main() {
+    /*
+    GCC 4.8 -O3 resolves the function call into a constant.
+    */
+    printf("%d\n", my_function(1, 2));
+    return 0;
+}
diff --git a/compiler-generated/gcc.md b/compiler-generated/gcc.md
@@ -1,5 +1,7 @@
 # GCC
 
+Tested with: GCC 4.8.
+
 ## Optimizations
 
 Without any flags, GCC will do several minor optimizations that make the code hard to read for beginners. Don't be afraid :-)
@@ -14,3 +16,13 @@ Common ones:
 ## Label names
 
 <http://stackoverflow.com/a/30212164/895245>
+
+## Optimizations
+
+-   `RBP` optimized out `-fomit-frame-pointer`
+
+-   operate on the correct register for the return value
+
+        int f(i, j) { return i + j; }
+
+    is doable in a single `lea`.
diff --git a/compiler-generated/ld.c b/compiler-generated/ld.c
@@ -0,0 +1,15 @@
+/* Stuff that ld might define. */
+
+#include <stdio.h>
+
+#define F(x) extern char x; \
+    printf(#x " = %p\n", &x);
+
+int main() {
+    F(etext)
+    F(edata)
+    F(end)
+    F(__data_start)
+    F(_GLOBAL_OFFSET_TABLE_)
+    return 0;
+}
diff --git a/compiler-generated/long_double_sum.c b/compiler-generated/long_double_sum.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    long double f;
+    f = (long double)(time(NULL) % 3);
+    /*
+    GCC 4.8: faddp by default. Constrast wth double which uses SSE.
+
+    Reason: FPU has the 80-bit operations which GCC uses for `long double`.
+    There is no 128-bit instrution in SSE.
+    */
+    f += 0.5L;
+    printf("%Lf\n", f);
+    return 0;
+}
diff --git a/compiler-generated/modulo.c b/compiler-generated/modulo.c
@@ -0,0 +1,14 @@
+/*
+GCC 4.8 uses a complicated set of instructions to avoid div which is a very slow instruction.
+
+http://stackoverflow.com/questions/4361979/how-does-the-gcc-implementation-of-module-work-and-why-does-it-not-use-the
+*/
+
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    int i = (int)(time(NULL) % 3);
+    printf("%d\n", i);
+    return 0;
+}
diff --git a/compiler-generated/sqrt.c b/compiler-generated/sqrt.c
@@ -0,0 +1,12 @@
+#include <math.h>
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+    float f;
+    f = time(NULL) % 3;
+    /* Calls glibc, which uses `sqrtsd` */
+    f = sqrt(f);
+    printf("%f\n", f);
+    return 0;
+}
diff --git a/compiler-generated/static_local.c b/compiler-generated/static_local.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int f() {
+    static int i = 1;
+    i++;
+    return i;
+}
+
+int main() {
+    printf("%d\n", f());
+    printf("%d\n", f());
+    return 0;
+}
diff --git a/compiler-generated/use_rax.c b/compiler-generated/use_rax.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+int global = 0;
+
+int my_function() {
+    /*
+    Is the compiler smart enough to move global into `rax` to increment it,
+    to reuse that for the return value?
+
+    For GCC 4.8:
+
+    - without `-O3`: rax used by default, but an extra mov from global to eax is done
+    - with `O3`: no extra move. TODO find exact flag that enables this.
+    */
+    global++;
+    return global;
+}
+
+int main() {
+    printf("%d\n", my_function());
+    printf("%d\n", my_function());
+    return 0;
+}
diff --git a/compiler-generated/use_rax_return.c b/compiler-generated/use_rax_return.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+int global = 0;
+
+int my_function() {
+    /*
+    Is the compiler smart enough to move global into `rax` to increment it,
+    to reuse that for the return value?
+
+    Yes for GCC 4.8 -O3
+    */
+    global++;
+    return global;
+}
+
+int main() {
+    printf("%d\n", my_function());
+    printf("%d\n", my_function());
+    return 0;
+}
diff --git a/elf-hello-world.md b/elf-hello-world.md
diff --git a/elf.md b/elf.md
diff --git a/ia-32/main.asm b/ia-32/main.asm
diff --git a/objdump.md b/objdump.md
diff --git a/readelf.md b/readelf.md
diff --git a/x86-64/main.asm b/x86-64/main.asm
