[debuginfo-tests] [dexter] Add test to check debug experience with __attribute__((optnone))

[n-omer]

Summary

This diff adds a test that checks debugging experience in functions that are marked __attribute__((optnone)) and have loops inside them.

[TWeaver]

Hey Nabeel, thanks for this.

[TWeaver]

I'll get this committed for you shortly.

[ldionne]

I don't think this was meant to be committed to <llvm-root>/dexter-tests/optnone-loops.cpp. Am I mistaken?

[ldionne]

In D89873#2378687, @ldionne wrote:

I don't think this was meant to be committed to <llvm-root>/dexter-tests/optnone-loops.cpp. Am I mistaken?

See https://reviews.llvm.org/D90931.

dexter-tests/optnone-loops.cpp

+// Purpose:
+// Verifies that the debugging experience of loops marked optnone is as expected.
+
+// REQUIRES: lldb
+// UNSUPPORTED: system-windows
+
+// RUN: %dexter --fail-lt 1.0 -w \
+// RUN:     --builder 'clang' --debugger 'lldb' \
+// RUN:     --cflags "-O2 -g" -- %s
+
+// A simple loop of assignments.
+// With optimization level > 0 the compiler reorders basic blocks
+// based on the basic block frequency analysis information.
+// This also happens with optnone and it shouldn't.
+// This is not affecting debug info so it is a minor limitation.
+// Basic block placement based on the block frequency analysis
+// is normally done to improve i-Cache performances.
+__attribute__((optnone)) void simple_memcpy_loop(int *dest, const int *src,
+                                                 unsigned nelems) {
+  for (unsigned i = 0; i != nelems; ++i)
+    dest[i] = src[i]; // DexLabel('target_simple_memcpy_loop')
+}
+
+// DexLimitSteps('i', 0, 4, 8, on_line='target_simple_memcpy_loop')
+// DexExpectWatchValue('nelems', '16', on_line='target_simple_memcpy_loop')
+// DexExpectWatchValue('src[i]', '3', '7', '1', on_line='target_simple_memcpy_loop')
+
+
+// A trivial loop that could be optimized into a builtin memcpy
+// which is either expanded into a optimal sequence of mov
+// instructions or directly into a call to memset@plt
+__attribute__((optnone)) void trivial_memcpy_loop(int *dest, const int *src) {
+  for (unsigned i = 0; i != 16; ++i)
+    dest[i] = src[i]; // DexLabel('target_trivial_memcpy_loop')
+}
+
+// DexLimitSteps('i', 3, 7, 9, 14, 15, on_line='target_trivial_memcpy_loop')
+// DexExpectWatchValue('i', 3, 7, 9, 14, 15, on_line='target_trivial_memcpy_loop')
+// DexExpectWatchValue('dest[i-1] == src[i-1]', 'true', on_line='target_trivial_memcpy_loop')
+
+
+__attribute__((always_inline)) int foo(int a) { return a + 5; }
+
+// A trivial loop of calls to a 'always_inline' function.
+__attribute__((optnone)) void nonleaf_function_with_loop(int *dest,
+                                                         const int *src) {
+  for (unsigned i = 0; i != 16; ++i)
+    dest[i] = foo(src[i]); // DexLabel('target_nonleaf_function_with_loop')
+}
+
+// DexLimitSteps('i', 1, on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('dest[0]', '8', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('dest[1]', '4', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('dest[2]', '5', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('src[0]', '8', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('src[1]', '4', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('src[2]', '5', on_line='target_nonleaf_function_with_loop')
+
+// DexExpectWatchValue('src[1] == dest[1]', 'true', on_line='target_nonleaf_function_with_loop')
+// DexExpectWatchValue('src[2] == dest[2]', 'true', on_line='target_nonleaf_function_with_loop')
+
+
+// This entire function could be optimized into a
+// simple movl %esi, %eax.
+// That is because we can compute the loop trip count
+// knowing that ind-var 'i' can never be negative.
+__attribute__((optnone)) int counting_loop(unsigned values) {
+  unsigned i = 0;
+  while (values--) // DexLabel('target_counting_loop')
+    i++;
+  return i;
+}
+
+// DexLimitSteps('i', 8, 16, on_line='target_counting_loop')
+// DexExpectWatchValue('i', 8, 16, on_line='target_counting_loop')
+
+
+// This loop could be rotated.
+// while(cond){
+//   ..
+//   cond--;
+// }
+//
+//  -->
+// if(cond) {
+//   do {
+//     ...
+//     cond--;
+//   } while(cond);
+// }
+//
+// the compiler will not try to optimize this function.
+// However the Machine BB Placement Pass will try
+// to reorder the basic block that computes the
+// expression 'count' in order to simplify the control
+// flow.
+__attribute__((optnone)) int loop_rotate_test(int *src, unsigned count) {
+  int result = 0;
+
+  while (count) {
+    result += src[count - 1]; // DexLabel('target_loop_rotate_test')
+    count--;
+  }
+  return result; // DexLabel('target_loop_rotate_test_ret')
+}
+
+// DexLimitSteps('result', 13, on_line='target_loop_rotate_test')
+// DexExpectWatchValue('src[count]', 13, on_line='target_loop_rotate_test')
+// DexLimitSteps('result', 158, on_line='target_loop_rotate_test_ret')
+// DexExpectWatchValue('result', 158, on_line='target_loop_rotate_test_ret')
+
+
+typedef int *intptr __attribute__((aligned(16)));
+
+// This loop can be vectorized if we enable
+// the loop vectorizer.
+__attribute__((optnone)) void loop_vectorize_test(intptr dest, intptr src) {
+  unsigned count = 0;
+
+  int tempArray[16];
+
+  while(count != 16) { // DexLabel('target_loop_vectorize_test')
+    tempArray[count] = src[count];
+    tempArray[count+1] = src[count+1]; // DexLabel('target_loop_vectorize_test_2')
+    tempArray[count+2] = src[count+2]; // DexLabel('target_loop_vectorize_test_3')
+    tempArray[count+3] = src[count+3]; // DexLabel('target_loop_vectorize_test_4')
+    dest[count] = tempArray[count]; // DexLabel('target_loop_vectorize_test_5')
+    dest[count+1] = tempArray[count+1]; // DexLabel('target_loop_vectorize_test_6')
+    dest[count+2] = tempArray[count+2]; // DexLabel('target_loop_vectorize_test_7')
+    dest[count+3] = tempArray[count+3]; // DexLabel('target_loop_vectorize_test_8')
+    count += 4; // DexLabel('target_loop_vectorize_test_9')
+  }
+}
+
+// DexLimitSteps('count', 4, 8, 12, 16, from_line='target_loop_vectorize_test', to_line='target_loop_vectorize_test_9')
+// DexExpectWatchValue('tempArray[count] == src[count]', 'true', on_line='target_loop_vectorize_test_2')
+// DexExpectWatchValue('tempArray[count+1] == src[count+1]', 'true', on_line='target_loop_vectorize_test_3')
+// DexExpectWatchValue('tempArray[count+2] == src[count+2]', 'true', on_line='target_loop_vectorize_test_4')
+// DexExpectWatchValue('tempArray[count+3] == src[count+3]', 'true', on_line='target_loop_vectorize_test_5')
+// DexExpectWatchValue('dest[count] == tempArray[count]', 'true', on_line='target_loop_vectorize_test_6')
+// DexExpectWatchValue('dest[count+1] == tempArray[count+1]', 'true', on_line='target_loop_vectorize_test_7')
+// DexExpectWatchValue('dest[count+2] == tempArray[count+2]', 'true', on_line='target_loop_vectorize_test_8')
+// DexExpectWatchValue('dest[count+3] == tempArray[count+3]', 'true', on_line='target_loop_vectorize_test_9')
+
+
+int main() {
+  int A[] = {3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  int B[] = {13, 14, 15, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+  int C[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+  simple_memcpy_loop(C, A, 16);
+  trivial_memcpy_loop(B, C);
+  nonleaf_function_with_loop(B, B);
+  int count = counting_loop(16);
+  count += loop_rotate_test(B, 16);
+  loop_vectorize_test(A, B);
+
+  return A[0] + count;
+}
+