Add more examples and solutions for kocher

BCB/Paul Kocher/Example 14/ex14_sol.c

+#include "../ex_main.h"
+
+void victim_function_v14(size_t x) {
+    if (x < array1_size) {
+        uint8_t v = array1[x ^ 255] * 512;
+        _mm_lfence();
+        temp &= array2[v];
+    }
+}

BCB/Paul Kocher/Example 15/ex15.c

+#include "../ex_main.h"
+
 void victim_function_v15(size_t *x) {
      if (*x < array1_size)
           temp &= array2[array1[*x] * 512];

BCB/Paul Kocher/Example 15/ex15_sol.c

+#include "../ex_main.h"
+
+void victim_function_v15(size_t *x) {
+    if (*x < array1_size) {
+        uint8_t v = array1[*x] * 512;
+        _mm_lfence();
+        temp &= array2[v];
+    }
+}
\ No newline at end of file

BCB/Paul Kocher/Example 2/ex02.c

+#include "../ex_main.h"
+
 void leakByteLocalFunction_v02(uint8_t k) {
      temp &= array2[(k)* 512];
 }

BCB/Paul Kocher/Example 2/ex02_ms.c

+#include "../ex_main.h"
+
+void leakByteLocalFunction_v02(uint8_t k) {
+    __mm_lfence();
+    temp &= array2[(k)* 512];
+}
+
+void ms_solution_v02(size_t x) {
+    if (x < array1_size) {
+        leakByteLocalFunction(array1[x]);
+    }
+}

BCB/Paul Kocher/Example 2/ex02_optimal.c

+#include "../ex_main.h"
+
+void leakByteLocalFunction_v02(uint8_t k) {
+    uint8_t v = k * 512;
+    __mm_lfence();
+    temp &= array2[v];
+}
+
+void optimal_solution_v02(size_t x) {
+    if (x < array1_size) {
+        leakByteLocalFunction(array1[x]);
+    }
+}

BCB/Paul Kocher/Example 3/ex03.c

-__declspec(noinline) void leakByteNoinlineFunction(uint8_t k) { temp &= array2[(k)* 512]; }
+#include "../ex_main.h"
+
+__declspec(noinline) void leakByteNoinlineFunction(uint8_t k) {
+    temp &= array2[(k)* 512]; 
+}
+
 void victim_function_v03(size_t x) {
-     if (x < array1_size)
-          leakByteNoinlineFunction(array1[x]);
+    if (x < array1_size)
+        leakByteNoinlineFunction(array1[x]);
 }

BCB/Paul Kocher/Example 3/ex03_sol.c

+#include "../ex_main.h"
+
+__declspec(noinline) void leakByteNoinlineFunction(uint8_t k) { 
+    uint8_t v = (k)* 512;
+    _mm_lfence();
+    temp &= array2[v];
+}
+
+void solution_v03(size_t x) {
+    if (x < array1_size)
+        leakByteNoinlineFunction(array1[x]);
+}

BCB/Paul Kocher/Example 4/ex04.c

+#include "../ex_main.h"
+
 void victim_function_v04(size_t x) {
-     if (x < array1_size)
-          temp &= array2[array1[x << 1] * 512];
-}
\ No newline at end of file
+    if (x < array1_size)
+        temp &= array2[array1[x << 1] * 512];
+}

BCB/Paul Kocher/Example 4/ex04_sol.c

+#include "../ex_main.h"
+
+void solution_v04(size_t x) {
+    if (x < array1_size)
+        uint8_t v = array1[x << 1] * 512;
+        temp &= array2[v];
+}

BCB/Paul Kocher/Example 5/ex05.c

+#include "../ex_main.h"
+
 void victim_function_v05(size_t x) {
-     size_t i;
-     if (x < array1_size) {
-          for (i = x - 1; i >= 0; i--)
-               temp &= array2[array1[i] * 512];
-     }
-}
\ No newline at end of file
+    size_t i;
+    if (x < array1_size) {
+        for (i = x - 1; i >= 0; i--)
+            temp &= array2[array1[i] * 512];
+    }
+}

BCB/Paul Kocher/Example 5/ex05_cheang_sol.c

+#include "../ex_main.h"
+
+void cheang_solution_v05(size_t x) {
+    size_t i;
+    if (x < array1_size) {
+        for (i = x - 1; i >= 0; i--) {
+            _mm_lfence();
+            temp &= array2[array1[i] * 512];
+        }
+    }
+}

BCB/Paul Kocher/Example 5/ex05_sol.c

+#include "../ex_main.h"
+
+void optimal_solution_v05(size_t x) {
+    size_t i;
+    if (x < array1_size) {
+        for (i = x - 1; i >= 0; i--) {
+            uint8_t v = array1[i] * 512;
+            _mm_lfence();
+            temp &= array2[v];
+        }
+    }
+}

BCB/Paul Kocher/Example 6/ex06.c

+#include "../ex_main.h"
+
 void victim_function_v06(size_t x) {
-     if ((x & array_size_mask) == x)
-          temp &= array2[array1[x] * 512];
-}
\ No newline at end of file
+    if ((x & array_size_mask) == x)
+        temp &= array2[array1[x] * 512];
+}

BCB/Paul Kocher/Example 6/ex06_sol.c

+#include "../ex_main.h"
+
+void solution_v06(size_t x) {
+    if ((x & array_size_mask) == x)
+        uint8_t v = array1[x] * 512;
+        _mm_lfence();
+        temp &= array2[v];
+}

BCB/Paul Kocher/Example 7/ex07.c

-void victim_function_v07(size_t x) {
-     static size_t last_x = 0;
-     if (x == last_x)
-          temp &= array2[array1[x] * 512];
-     if (x < array1_size)
-          last_x = x;
-}
\ No newline at end of file
+#include "../ex_main.h"
+
+void optimal_sol_v07(size_t x) {
+    static size_t last_x = 0;
+    if (x == last_x)
+        temp &= array2[array1[x] * 512];
+    if (x < array1_size)
+        last_x = x;
+}

BCB/Paul Kocher/Example 7/ex07_cheang.c

+#include "../ex_main.h"
+
+void optimal_sol_v07(size_t x) {
+    static size_t last_x = 0;
+    if (x == last_x) {
+        _mm_lfence();
+        temp &= array2[array1[x] * 512];
+    }
+    if (x < array1_size)
+        last_x = x;
+}

BCB/Paul Kocher/Example 7/ex07_sol.c

+#include "../ex_main.h"
+
+void optimal_sol_v07(size_t x) {
+    static size_t last_x = 0;
+    if (x == last_x) {
+        uint8_t v = array1[x] * 512;
+        _mm_lfence();
+        temp &= array2[v];
+    }
+    if (x < array1_size)
+        last_x = x;
+}

BCB/Paul Kocher/Example 8/ex08.c

+#include "../ex_main.h"
+
 void victim_function_v08(size_t x) {
-     temp &= array2[array1[x < array1_size ? (x + 1) : 0] * 512];
+    temp &= array2[array1[x < array1_size ? (x + 1) : 0] * 512];
 }
\ No newline at end of file

BCB/Paul Kocher/Example 8/ex08_cheang.c

+#include "../ex_main.h"
+
+void cheang_sol_v08(size_t x) {
+    bool cond = x < array1_size;
+    _mm_lfence();
+    temp &= array2[array1[cond ? (x + 1) : 0] * 512];
+}