cross-project-tests/debuginfo-tests/dexter-tests/optnone-loops.cpp

   1 // Purpose:
   2 // Verifies that the debugging experience of loops marked optnone is as expected.
   3
   4 // REQUIRES: lldb
   5 // UNSUPPORTED: system-windows
   6 // UNSUPPORTED: system-darwin
   7
   8 // RUN: %clang -std=gnu++11 -O2 -g %s -o %t
   9 // RUN: %dexter --fail-lt 1.0 -w \
  10 // RUN:     --binary %t --debugger 'lldb' -- %s
  11
  12 // A simple loop of assignments.
  13 // With optimization level > 0 the compiler reorders basic blocks
  14 // based on the basic block frequency analysis information.
  15 // This also happens with optnone and it shouldn't.
  16 // This is not affecting debug info so it is a minor limitation.
  17 // Basic block placement based on the block frequency analysis
  18 // is normally done to improve i-Cache performances.
  19 __attribute__((optnone)) void simple_memcpy_loop(int *dest, const int *src,
  20                                                  unsigned nelems) {
  21   for (unsigned i = 0; i != nelems; ++i)
  22     dest[i] = src[i]; // DexLabel('target_simple_memcpy_loop')
  23 }
  24
  25 // DexLimitSteps('i', 0, 4, 8, on_line=ref('target_simple_memcpy_loop'))
  26 // DexExpectWatchValue('nelems', '16', on_line=ref('target_simple_memcpy_loop'))
  27 // DexExpectWatchValue('src[i]', '3', '7', '1', on_line=ref('target_simple_memcpy_loop'))
  28
  29
  30 // A trivial loop that could be optimized into a builtin memcpy
  31 // which is either expanded into a optimal sequence of mov
  32 // instructions or directly into a call to memset@plt
  33 __attribute__((optnone)) void trivial_memcpy_loop(int *dest, const int *src) {
  34   for (unsigned i = 0; i != 16; ++i)
  35     dest[i] = src[i]; // DexLabel('target_trivial_memcpy_loop')
  36 }
  37
  38 // DexLimitSteps('i', 3, 7, 9, 14, 15, on_line=ref('target_trivial_memcpy_loop'))
  39 // DexExpectWatchValue('i', 3, 7, 9, 14, 15, on_line=ref('target_trivial_memcpy_loop'))
  40 // DexExpectWatchValue('dest[i-1] == src[i-1]', 'true', on_line=ref('target_trivial_memcpy_loop'))
  41
  42
  43 __attribute__((always_inline)) int foo(int a) { return a + 5; }
  44
  45 // A trivial loop of calls to a 'always_inline' function.
  46 __attribute__((optnone)) void nonleaf_function_with_loop(int *dest,
  47                                                          const int *src) {
  48   for (unsigned i = 0; i != 16; ++i)
  49     dest[i] = foo(src[i]); // DexLabel('target_nonleaf_function_with_loop')
  50 }
  51
  52 // DexLimitSteps('i', 1, on_line=ref('target_nonleaf_function_with_loop'))
  53 // DexExpectWatchValue('dest[0]', '8', on_line=ref('target_nonleaf_function_with_loop'))
  54 // DexExpectWatchValue('dest[1]', '4', on_line=ref('target_nonleaf_function_with_loop'))
  55 // DexExpectWatchValue('dest[2]', '5', on_line=ref('target_nonleaf_function_with_loop'))
  56 // DexExpectWatchValue('src[0]', '8', on_line=ref('target_nonleaf_function_with_loop'))
  57 // DexExpectWatchValue('src[1]', '4', on_line=ref('target_nonleaf_function_with_loop'))
  58 // DexExpectWatchValue('src[2]', '5', on_line=ref('target_nonleaf_function_with_loop'))
  59
  60 // DexExpectWatchValue('src[1] == dest[1]', 'true', on_line=ref('target_nonleaf_function_with_loop'))
  61 // DexExpectWatchValue('src[2] == dest[2]', 'true', on_line=ref('target_nonleaf_function_with_loop'))
  62
  63
  64 // This entire function could be optimized into a
  65 // simple movl %esi, %eax.
  66 // That is because we can compute the loop trip count
  67 // knowing that ind-var 'i' can never be negative.
  68 __attribute__((optnone)) int counting_loop(unsigned values) {
  69   unsigned i = 0;
  70   while (values--) // DexLabel('target_counting_loop')
  71     i++;
  72   return i;
  73 }
  74
  75 // DexLimitSteps('i', 8, 16, on_line=ref('target_counting_loop'))
  76 // DexExpectWatchValue('i', 8, 16, on_line=ref('target_counting_loop'))
  77
  78
  79 // This loop could be rotated.
  80 // while(cond){
  81 //   ..
  82 //   cond--;
  83 // }
  84 //
  85 //  -->
  86 // if(cond) {
  87 //   do {
  88 //     ...
  89 //     cond--;
  90 //   } while(cond);
  91 // }
  92 //
  93 // the compiler will not try to optimize this function.
  94 // However the Machine BB Placement Pass will try
  95 // to reorder the basic block that computes the
  96 // expression 'count' in order to simplify the control
  97 // flow.
  98 __attribute__((optnone)) int loop_rotate_test(int *src, unsigned count) {
  99   int result = 0;
 100
 101   while (count) {
 102     result += src[count - 1]; // DexLabel('target_loop_rotate_test')
 103     count--;
 104   }
 105   return result; // DexLabel('target_loop_rotate_test_ret')
 106 }
 107
 108 // DexLimitSteps('result', 13, on_line=ref('target_loop_rotate_test'))
 109 // DexExpectWatchValue('src[count]', 13, on_line=ref('target_loop_rotate_test'))
 110 // DexLimitSteps('result', 158, on_line=ref('target_loop_rotate_test_ret'))
 111 // DexExpectWatchValue('result', 158, on_line=ref('target_loop_rotate_test_ret'))
 112
 113
 114 typedef int *intptr __attribute__((aligned(16)));
 115
 116 // This loop can be vectorized if we enable
 117 // the loop vectorizer.
 118 __attribute__((optnone)) void loop_vectorize_test(intptr dest, intptr src) {
 119   unsigned count = 0;
 120
 121   int tempArray[16];
 122
 123   while(count != 16) { // DexLabel('target_loop_vectorize_test')
 124     tempArray[count] = src[count];
 125     tempArray[count+1] = src[count+1]; // DexLabel('target_loop_vectorize_test_2')
 126     tempArray[count+2] = src[count+2]; // DexLabel('target_loop_vectorize_test_3')
 127     tempArray[count+3] = src[count+3]; // DexLabel('target_loop_vectorize_test_4')
 128     dest[count] = tempArray[count]; // DexLabel('target_loop_vectorize_test_5')
 129     dest[count+1] = tempArray[count+1]; // DexLabel('target_loop_vectorize_test_6')
 130     dest[count+2] = tempArray[count+2]; // DexLabel('target_loop_vectorize_test_7')
 131     dest[count+3] = tempArray[count+3]; // DexLabel('target_loop_vectorize_test_8')
 132     count += 4; // DexLabel('target_loop_vectorize_test_9')
 133   }
 134 }
 135
 136 // DexLimitSteps('count', 4, 8, 12, 16, from_line=ref('target_loop_vectorize_test'), to_line=ref('target_loop_vectorize_test_9'))
 137 // DexExpectWatchValue('tempArray[count] == src[count]', 'true', on_line=ref('target_loop_vectorize_test_2'))
 138 // DexExpectWatchValue('tempArray[count+1] == src[count+1]', 'true', on_line=ref('target_loop_vectorize_test_3'))
 139 // DexExpectWatchValue('tempArray[count+2] == src[count+2]', 'true', on_line=ref('target_loop_vectorize_test_4'))
 140 // DexExpectWatchValue('tempArray[count+3] == src[count+3]', 'true', on_line=ref('target_loop_vectorize_test_5'))
 141 // DexExpectWatchValue('dest[count] == tempArray[count]', 'true', on_line=ref('target_loop_vectorize_test_6'))
 142 // DexExpectWatchValue('dest[count+1] == tempArray[count+1]', 'true', on_line=ref('target_loop_vectorize_test_7'))
 143 // DexExpectWatchValue('dest[count+2] == tempArray[count+2]', 'true', on_line=ref('target_loop_vectorize_test_8'))
 144 // DexExpectWatchValue('dest[count+3] == tempArray[count+3]', 'true', on_line=ref('target_loop_vectorize_test_9'))
 145
 146
 147 int main() {
 148   int A[] = {3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 149   int B[] = {13, 14, 15, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 150   int C[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 151
 152   simple_memcpy_loop(C, A, 16);
 153   trivial_memcpy_loop(B, C);
 154   nonleaf_function_with_loop(B, B);
 155   int count = counting_loop(16);
 156   count += loop_rotate_test(B, 16);
 157   loop_vectorize_test(A, B);
 158
 159   return A[0] + count;
 160 }
 161