[dexter] Change line label reference syntax to enable label-relative offsets (2/2)

[Orlando]

Summary

Update dexter tests to use the new line label reference syntax introduced in D101147.

Updated with:
https://gist.github.com/OCHyams/8255efe7757cac266440ed2ba55f1442

[chrisjackson]

LGTM.

[jmorse]

LGTM

debuginfo-tests/dexter-tests/aggregate-indirect-arg.cpp

int main() {
   a.foo(v);
   return 0;
 }
 
 /*
 DexExpectProgramState({
   'frames': [
     {
-      'location': { 'lineno': 'foo' },
+      'location': { 'lineno': ref('foo') },
       'watches': {
         'v.Data == 0': 'true',
         'v.Kind': '2142'
       }
     }
   ]
 })
 */
 

debuginfo-tests/dexter-tests/asan-deque.cpp

int main() {
   escape(deq); // DexLabel('first')
   while (!deq.empty()) {
     auto record = deq.front();
     deq.pop_front();
     escape(deq); // DexLabel('second')
   }
 }
 
-// DexExpectWatchValue('deq[0].a', '1234', on_line='first')
-// DexExpectWatchValue('deq[1].a', '56789', on_line='first')
+// DexExpectWatchValue('deq[0].a', '1234', on_line=ref('first'))
+// DexExpectWatchValue('deq[1].a', '56789', on_line=ref('first'))
 
-// DexExpectWatchValue('deq[0].a', '56789', '0', on_line='second')
+// DexExpectWatchValue('deq[0].a', '56789', '0', on_line=ref('second'))
 

debuginfo-tests/dexter-tests/asan.c

 
 int main(int argc, const char **argv) {
   struct S s = {{0, 1, 2, 3, 4, 5, 6, 7}};
   if (f(s, 4) == 4)
     return f(s, 0);
   return 0;
 }
 
-// DexExpectWatchValue('s.a[0]', '0', on_line='asan')
-// DexExpectWatchValue('s.a[1]', '1', on_line='asan')
-// DexExpectWatchValue('s.a[7]', '7', on_line='asan')
+// DexExpectWatchValue('s.a[0]', '0', on_line=ref('asan'))
+// DexExpectWatchValue('s.a[1]', '1', on_line=ref('asan'))
+// DexExpectWatchValue('s.a[7]', '7', on_line=ref('asan'))
 

debuginfo-tests/dexter-tests/ctor.cpp

 }
 
 
 /*
 DexExpectProgramState({
   'frames': [
     {
       'location': {
-        'lineno': 'ctor_start'
+        'lineno': ref('ctor_start')
       },
       'watches': {
         '*this': {'is_irretrievable': False}
       }
     }
   ]
 })
 */
 

debuginfo-tests/dexter-tests/dbg-arg.c

int main() {
   return foobar(&m);
 }
 
 
 /*
 DexExpectProgramState({
   'frames': [
     {
-      'location': { 'lineno': 'l_assign' },
+      'location': { 'lineno': ref('l_assign') },
       'watches': {
         '*mutex': { 'is_irretrievable': False }
       }
     }
   ]
 })
 */
 

debuginfo-tests/dexter-tests/deferred_globals.cpp

int main() {
   const char *f = "Woopy";
   return d + foo();
 }
 
 int foo() {
   return d; // DexLabel("foo")
 }
 
-// DexExpectWatchValue('d', '4', on_line='main')
-// DexExpectWatchValue('d', '100', on_line='foo')
+// DexExpectWatchValue('d', '4', on_line=ref('main'))
+// DexExpectWatchValue('d', '100', on_line=ref('foo'))
 

debuginfo-tests/dexter-tests/global-constant.cpp

 void useConst(int) {}
 int main() {
   useConst(TestPi);
   useConst(S::TestCharA);
   useConst(ENUM_NEG); // DexLabel('stop')
   return 0;
 }
 
-// DexExpectWatchValue('TestPi', 3.140000104904175, on_line='stop')
-// DexExpectWatchValue('S::TestCharA', 97, on_line='stop')
-// DexExpectWatchValue('ENUM_NEG', -2147000000, on_line='stop')
+// DexExpectWatchValue('TestPi', 3.140000104904175, on_line=ref('stop'))
+// DexExpectWatchValue('S::TestCharA', 97, on_line=ref('stop'))
+// DexExpectWatchValue('ENUM_NEG', -2147000000, on_line=ref('stop'))
 /* DexExpectProgramState({'frames': [{
-               'location': {'lineno' : 'stop'},
+               'location': {'lineno' : ref('stop')},
                'watches': {'ENUM_POS' : {'is_irretrievable': True}}
 }]}) */

debuginfo-tests/dexter-tests/hello.c

 // REQUIRES: system-windows
 //
 // RUN: %dexter --fail-lt 1.0 -w --builder 'clang-cl_vs2015' \
 // RUN:      --debugger 'dbgeng' --cflags '/Z7 /Zi' --ldflags '/Z7 /Zi' -- %s
 
 #include <stdio.h>
 int main() {
   printf("hello world\n");
   int x = 42;
   __debugbreak(); // DexLabel('stop')
 }
 
-// DexExpectWatchValue('x', 42, on_line='stop')
+// DexExpectWatchValue('x', 42, on_line=ref('stop'))

debuginfo-tests/dexter-tests/inline-line-gap.cpp

 }
 
 int __attribute__((optnone)) main() {
   callerOfInlineCrashFrame(true);
 }
 
 /*
 DexExpectProgramState({'frames':[
-     {'function': 'inlineCrashFrame', 'location':{'lineno' : 'stop'} },
+     {'function': 'inlineCrashFrame', 'location':{'lineno' : ref('stop')} },
      {'function': 'callerOfInlineCrashFrame'},
      {'function': 'main'}
 ]})
 */

debuginfo-tests/dexter-tests/memvars/bitcast.c

int main() {
   int y = getint(5); // DexLabel('s1')
   int z = getint(5); // DexLabel('s2')
   alias((char*)&x);  // DexLabel('s3')
   alias((char*)&y);
   alias((char*)&z);
   return 0;          // DexLabel('s4')
 }
 
-// DexExpectWatchValue('x', '5',  from_line='s1', to_line='s4')
-// DexExpectWatchValue('y', '5',  from_line='s2', to_line='s4')
-// DexExpectWatchValue('z', '5',  from_line='s3', to_line='s4')
+// DexExpectWatchValue('x', '5',  from_line=ref('s1'), to_line=ref('s4'))
+// DexExpectWatchValue('y', '5',  from_line=ref('s2'), to_line=ref('s4'))
+// DexExpectWatchValue('z', '5',  from_line=ref('s3'), to_line=ref('s4'))

debuginfo-tests/dexter-tests/memvars/const-branch.c

int fun(int param) {
   }
   return 0; //                                            DexLabel('s2')
 }
 
 int main() {
   return fun(5);
 }
 
-// DexExpectWatchValue('param', '5',  from_line='s1', to_line='s2')
+// DexExpectWatchValue('param', '5',  from_line=ref('s1'), to_line=ref('s2'))
 

debuginfo-tests/dexter-tests/memvars/ctrl-flow.c

 
 int main() {
   int a = fun(1);
   int b = fun(0);
   return a + b;
 }
 
 ////                           fun(1)  fun(0)
-// DexExpectWatchValue('local',   '0',    '0', on_line='s1')
-// DexExpectWatchValue('local',   '2',    '1', on_line='s2')
+// DexExpectWatchValue('local',   '0',    '0', on_line=ref('s1'))
+// DexExpectWatchValue('local',   '2',    '1', on_line=ref('s2'))

debuginfo-tests/dexter-tests/memvars/implicit-ptr.c

int fun(int param) {
   use_inline(&param);
   return step;             // DexLabel('s4')
 }
 
 int main() {
   return fun(5);
 }
 
-// DexExpectWatchValue('param', 5, from_line='s1', to_line='s4')
-// DexExpectWatchValue('*pa', 5, on_line='s2')
-// DexExpectWatchValue('*pb', 5, on_line='s3')
+// DexExpectWatchValue('param', 5, from_line=ref('s1'), to_line=ref('s4'))
+// DexExpectWatchValue('*pa', 5, on_line=ref('s2'))
+// DexExpectWatchValue('*pb', 5, on_line=ref('s3'))

debuginfo-tests/dexter-tests/memvars/inline-escaping-function.c

int fun(int param) {
   fluff();           // DexLabel('s0')
   return param;
 }
 
 int main() {
   return fun(5);
 }
 
-// DexExpectWatchValue('param', 10, on_line='s0')
+// DexExpectWatchValue('param', 10, on_line=ref('s0'))

debuginfo-tests/dexter-tests/memvars/inlining-dse.c

 }
 
 int main() {
   fun(5);
 }
 
 /*
 # Expect param == 5 before stepping through inlined 'use'.
-DexExpectWatchValue('param', '5', on_line='fun1')
+DexExpectWatchValue('param', '5', on_line=ref('fun1'))
 
 # Expect param == 255 after assignment in inlined frame 'use'.
 DexExpectProgramState({
   'frames': [
     { 'function': 'use',
-      'location': { 'lineno': 'use1' },
+      'location': { 'lineno': ref('use1') },
     },
     { 'function': 'fun',
       'location': { 'lineno': 20 },
       'watches':  { 'param': '255' }
     },
   ]
 })
 
 # Expect param == 255 after inlined call to 'use'.
-DexExpectWatchValue('param', '255', on_line='fun2')
+DexExpectWatchValue('param', '255', on_line=ref('fun2'))
 */

debuginfo-tests/dexter-tests/memvars/inlining.c

void fun(int param) {
   use(&param);
   volatile int step2 = 0;  // DexLabel('s2')
 }
 
 int main() {
   fun(5);
 }
 
-// DexExpectWatchValue('param', '5', from_line='s1', to_line='s2')
+// DexExpectWatchValue('param', '5', from_line=ref('s1'), to_line=ref('s2'))

debuginfo-tests/dexter-tests/memvars/loop.c

int fun(int param) {
 
   return g;                           // DexLabel('s3')
 }
 
 int main() {
   return fun(5);
 }
 
-// DexExpectWatchValue('*p', 5, 5, 5, 5, 5, on_line='s1')
-// DexExpectWatchValue('param', 5, from_line='s2', to_line='s3')
+// DexExpectWatchValue('*p', 5, 5, 5, 5, 5, on_line=ref('s1'))
+// DexExpectWatchValue('param', 5, from_line=ref('s2'), to_line=ref('s3'))

debuginfo-tests/dexter-tests/memvars/merged-store.c

int fun(int parama, int paramb) {
   esc(&parama);
   return 0;
 }
 
 int main() {
   return fun(5, 20);
 }
 
-// DexExpectWatchValue('parama', 20, on_line='s0')
+// DexExpectWatchValue('parama', 20, on_line=ref('s0'))

debuginfo-tests/dexter-tests/memvars/ptr-to.c

int main() {
   int local = 0xA;
   int *plocal = &local;
   esc(plocal);      // DexLabel('s1')
   local = 0xB;      //// DSE
   return 0;         // DexLabel('s2')
 }
 
 
-// DexExpectWatchValue('local', 0xA, on_line='s1')
-// DexExpectWatchValue('local', 0xB, on_line='s2')
-// DexExpectWatchValue('*plocal', 0xA, on_line='s1')
-// DexExpectWatchValue('*plocal', 0xB, on_line='s2')
+// DexExpectWatchValue('local', 0xA, on_line=ref('s1'))
+// DexExpectWatchValue('local', 0xB, on_line=ref('s2'))
+// DexExpectWatchValue('*plocal', 0xA, on_line=ref('s1'))
+// DexExpectWatchValue('*plocal', 0xB, on_line=ref('s2'))
 //// Ideally we should be able to observe the dead store to local (0xB) through
 //// plocal here.
-// DexExpectWatchValue('(local == *plocal)', 'true', from_line='s1', to_line='s2')
+// DexExpectWatchValue('(local == *plocal)', 'true', from_line=ref('s1'), to_line=ref('s2'))

debuginfo-tests/dexter-tests/memvars/struct-dse.c

int main() {
 
   nums.c = 2;                        //// Killing store.
   printf("s2 nums.c: %d\n", nums.c); // DexLabel('s2')
 
   esc(&nums);                        //// Force nums to live on the stack.
   return 0;                          // DexLabel('s3')
 }
 
-// DexExpectWatchValue('nums.c', '1', on_line='s1')
-// DexExpectWatchValue('nums.c', '2', from_line='s2', to_line='s3')
+// DexExpectWatchValue('nums.c', '1', on_line=ref('s1'))
+// DexExpectWatchValue('nums.c', '2', from_line=ref('s2'), to_line=ref('s3'))

debuginfo-tests/dexter-tests/memvars/unused-merged-value.c

int fun(int parama, int paramb) {
   fluff();            // DexLabel('s0')
   return paramb;
 }
 
 int main() {
   return fun(5, 20);
 }
 
-// DexExpectWatchValue('parama', 20, on_line='s0')
+// DexExpectWatchValue('parama', 20, on_line=ref('s0'))
 //
 // NOTE: the dexter command uses --fail-lt 0.1 (instead of the standard 1.0)
 // because seeing 'optimized out' would still be a win; it's the best we can do
 // without using conditional DWARF operators in the location expression. Seeing
 // 'optimized out' should result in a score higher than 0.1.

debuginfo-tests/dexter-tests/namespace.cpp

 const int ape = 32;
 }
 
 int main() {
   printf("hello %d\n", monkey::ape); // DexLabel('main')
   return 0;
 }
 
-// DexExpectWatchValue('monkey::ape', 32, on_line='main')
+// DexExpectWatchValue('monkey::ape', 32, on_line=ref('main'))
 

debuginfo-tests/dexter-tests/nrvo-string.cpp

string2 __attribute__((noinline)) get_string2() {
   stop(); // DexLabel('string2-nrvo')
   return output;
 }
 int main() {
   get_string();
   get_string2();
 }
 
-// DexExpectWatchValue('output.i', 3, on_line='string-nrvo')
-// DexExpectWatchValue('output.i', 5, on_line='string2-nrvo')
+// DexExpectWatchValue('output.i', 3, on_line=ref('string-nrvo'))
+// DexExpectWatchValue('output.i', 5, on_line=ref('string2-nrvo'))
 

debuginfo-tests/dexter-tests/nrvo.cpp

string2 get_string2() {
   // function is called.
   return result; // DexLabel('readresult2')
 }
 int main() {
   get_string();
   get_string2();
 }
 
-// DexExpectWatchValue('result.i', 3, on_line='readresult1')
-// DexExpectWatchValue('result.i', 5, on_line='readresult2')
+// DexExpectWatchValue('result.i', 3, on_line=ref('readresult1'))
+// DexExpectWatchValue('result.i', 5, on_line=ref('readresult2'))

debuginfo-tests/dexter-tests/optnone-fastmath.cpp

 //// as equally precise. However we don't want this to happen
 //// with optnone.
 __attribute__((optnone))
 float test_fdiv(float A) {
   float result;
   result = A / 10.f;  // DexLabel('fdiv_assign')
   return result;      // DexLabel('fdiv_ret')
 }
-// DexExpectWatchValue('A', 4, on_line='fdiv_assign')
-// DexExpectWatchValue('result', '0.400000006', on_line='fdiv_ret')
+// DexExpectWatchValue('A', 4, on_line=ref('fdiv_assign'))
+// DexExpectWatchValue('result', '0.400000006', on_line=ref('fdiv_ret'))
 
 //// (A * B) - (A * C) ==> A * (B - C)
 __attribute__((optnone))
 float test_distributivity(float A, float B, float C) {
   float result;
   float op1 = A * B;
   float op2 = A * C;    // DexLabel('distributivity_op2')
   result = op1 - op2;   // DexLabel('distributivity_result')
   return result;        // DexLabel('distributivity_ret')
 }
-// DexExpectWatchValue('op1', '20', on_line='distributivity_op2')
-// DexExpectWatchValue('op2', '24', on_line='distributivity_result')
-// DexExpectWatchValue('result', '-4', on_line='distributivity_ret')
+// DexExpectWatchValue('op1', '20', on_line=ref('distributivity_op2'))
+// DexExpectWatchValue('op2', '24', on_line=ref('distributivity_result'))
+// DexExpectWatchValue('result', '-4', on_line=ref('distributivity_ret'))
 
 //// (A + B) + C  == A + (B + C)
 //// therefore, ((A + B) + C) + (A + (B + C)))
 //// can be rewritten as
 //// 2.0f * ((A + B) + C)
 //// Clang is currently unable to spot this optimization
 //// opportunity with fastmath.
 __attribute__((optnone))
 float test_associativity(float A, float B, float C) {
   float result;
   float op1 = A + B;
   float op2 = B + C;
   op1 += C;           // DexLabel('associativity_op1')
   op2 += A;
   result = op1 + op2; // DexLabel('associativity_result')
   return result;      // DexLabel('associativity_ret')
 }
-// DexExpectWatchValue('op1', '9', '15', from_line='associativity_op1', to_line='associativity_result')
-// DexExpectWatchValue('op2', '11', '15', from_line='associativity_op1', to_line='associativity_result')
-// DexExpectWatchValue('result', '30', on_line='associativity_ret')
+// DexExpectWatchValue('op1', '9', '15', from_line=ref('associativity_op1'), to_line=ref('associativity_result'))
+// DexExpectWatchValue('op2', '11', '15', from_line=ref('associativity_op1'), to_line=ref('associativity_result'))
+// DexExpectWatchValue('result', '30', on_line=ref('associativity_ret'))
 
 //// With fastmath, the ordering of instructions doesn't matter
 //// since we work under the assumption that there is no loss
 //// in precision. This simplifies things for the optimizer which
 //// can then decide to reorder instructions and fold
 //// redundant operations like this:
 ////   A += 5.0f
 ////   A -= 5.0f
 ////    -->
 ////   A
 //// This function can be simplified to a return A + B.
 __attribute__((optnone))
 float test_simplify_fp_operations(float A, float B) {
   float result = A + 10.0f; // DexLabel('fp_operations_result')
   result += B;              // DexLabel('fp_operations_add')
   result -= 10.0f;
   return result;            // DexLabel('fp_operations_ret')
 }
-// DexExpectWatchValue('A', '8.25', on_line='fp_operations_result')
-// DexExpectWatchValue('B', '26.3999996', on_line='fp_operations_result')
-// DexExpectWatchValue('result', '18.25', '44.6500015', '34.6500015', from_line='fp_operations_add', to_line='fp_operations_ret')
+// DexExpectWatchValue('A', '8.25', on_line=ref('fp_operations_result'))
+// DexExpectWatchValue('B', '26.3999996', on_line=ref('fp_operations_result'))
+// DexExpectWatchValue('result', '18.25', '44.6500015', '34.6500015', from_line=ref('fp_operations_add'), to_line=ref('fp_operations_ret'))
 
 //// Again, this is a simple return A + B.
 //// Clang is unable to spot the opportunity to fold the code sequence.
 __attribute__((optnone))
 float test_simplify_fp_operations_2(float A, float B, float C) {
   float result = A + C; // DexLabel('fp_operations_2_result')
   result += B;
   result -= C;          // DexLabel('fp_operations_2_subtract')
   return result;        // DexLabel('fp_operations_2_ret')
 }
-// DexExpectWatchValue('A', '9.11999988', on_line='fp_operations_2_result')
-// DexExpectWatchValue('B', '61.050003', on_line='fp_operations_2_result')
-// DexExpectWatchValue('C', '1002.11102', on_line='fp_operations_2_result')
-// DexExpectWatchValue('result', '1072.28101', '70.1699829', from_line='fp_operations_2_subtract', to_line='fp_operations_2_ret')
+// DexExpectWatchValue('A', '9.11999988', on_line=ref('fp_operations_2_result'))
+// DexExpectWatchValue('B', '61.050003', on_line=ref('fp_operations_2_result'))
+// DexExpectWatchValue('C', '1002.11102', on_line=ref('fp_operations_2_result'))
+// DexExpectWatchValue('result', '1072.28101', '70.1699829', from_line=ref('fp_operations_2_subtract'), to_line=ref('fp_operations_2_ret'))
 
 int main() {
   float result = test_fdiv(4.0f);
   result += test_distributivity(4.0f, 5.0f, 6.0f);
   result += test_associativity(4.0f, 5.0f, 6.0f);
   result += test_simplify_fp_operations(8.25, result);
   result += test_simplify_fp_operations_2(9.12, result, 1002.111);
   return static_cast<int>(result);
 }

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

 // 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')
+// DexLimitSteps('i', 0, 4, 8, on_line=ref('target_simple_memcpy_loop'))
+// DexExpectWatchValue('nelems', '16', on_line=ref('target_simple_memcpy_loop'))
+// DexExpectWatchValue('src[i]', '3', '7', '1', on_line=ref('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')
+// DexLimitSteps('i', 3, 7, 9, 14, 15, on_line=ref('target_trivial_memcpy_loop'))
+// DexExpectWatchValue('i', 3, 7, 9, 14, 15, on_line=ref('target_trivial_memcpy_loop'))
+// DexExpectWatchValue('dest[i-1] == src[i-1]', 'true', on_line=ref('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')
+// DexLimitSteps('i', 1, on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('dest[0]', '8', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('dest[1]', '4', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('dest[2]', '5', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('src[0]', '8', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('src[1]', '4', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('src[2]', '5', on_line=ref('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')
+// DexExpectWatchValue('src[1] == dest[1]', 'true', on_line=ref('target_nonleaf_function_with_loop'))
+// DexExpectWatchValue('src[2] == dest[2]', 'true', on_line=ref('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')
+// DexLimitSteps('i', 8, 16, on_line=ref('target_counting_loop'))
+// DexExpectWatchValue('i', 8, 16, on_line=ref('target_counting_loop'))
 
 
 // This loop could be rotated.
 // while(cond){
 //   ..
 //   cond--;
 // }
 //
__attribute__((optnone)) int loop_rotate_test(int *src, unsigned count) {
 
   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')
+// DexLimitSteps('result', 13, on_line=ref('target_loop_rotate_test'))
+// DexExpectWatchValue('src[count]', 13, on_line=ref('target_loop_rotate_test'))
+// DexLimitSteps('result', 158, on_line=ref('target_loop_rotate_test_ret'))
+// DexExpectWatchValue('result', 158, on_line=ref('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')
+// DexLimitSteps('count', 4, 8, 12, 16, from_line=ref('target_loop_vectorize_test'), to_line=ref('target_loop_vectorize_test_9'))
+// DexExpectWatchValue('tempArray[count] == src[count]', 'true', on_line=ref('target_loop_vectorize_test_2'))
+// DexExpectWatchValue('tempArray[count+1] == src[count+1]', 'true', on_line=ref('target_loop_vectorize_test_3'))
+// DexExpectWatchValue('tempArray[count+2] == src[count+2]', 'true', on_line=ref('target_loop_vectorize_test_4'))
+// DexExpectWatchValue('tempArray[count+3] == src[count+3]', 'true', on_line=ref('target_loop_vectorize_test_5'))
+// DexExpectWatchValue('dest[count] == tempArray[count]', 'true', on_line=ref('target_loop_vectorize_test_6'))
+// DexExpectWatchValue('dest[count+1] == tempArray[count+1]', 'true', on_line=ref('target_loop_vectorize_test_7'))
+// DexExpectWatchValue('dest[count+2] == tempArray[count+2]', 'true', on_line=ref('target_loop_vectorize_test_8'))
+// DexExpectWatchValue('dest[count+3] == tempArray[count+3]', 'true', on_line=ref('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);

debuginfo-tests/dexter-tests/optnone-simple-functions.cpp

 __attribute__((optnone))
 int test1(int test1_a, int test1_b) {
   int test1_result = 0;
   // DexLabel('test1_start')
   test1_result = test1_a + test1_b; // DexExpectStepOrder(1)
   return test1_result; // DexExpectStepOrder(2)
   // DexLabel('test1_end')
 }
-// DexExpectWatchValue('test1_a', 3, from_line='test1_start', to_line='test1_end')
-// DexExpectWatchValue('test1_b', 4, from_line='test1_start', to_line='test1_end')
-// DexExpectWatchValue('test1_result', 0, 7, from_line='test1_start', to_line='test1_end')
+// DexExpectWatchValue('test1_a', 3, from_line=ref('test1_start'), to_line=ref('test1_end'))
+// DexExpectWatchValue('test1_b', 4, from_line=ref('test1_start'), to_line=ref('test1_end'))
+// DexExpectWatchValue('test1_result', 0, 7, from_line=ref('test1_start'), to_line=ref('test1_end'))
 
 __attribute__((optnone))
 int test2(int test2_a, int test2_b) {
   int test2_result = test2_a + test2_a + test2_a + test2_a;  // DexExpectStepOrder(3)
   // DexLabel('test2_start')
   return test2_a << 2;   // DexExpectStepOrder(4)
   // DexLabel('test2_end')
 }
-// DexExpectWatchValue('test2_a', 1, from_line='test2_start', to_line='test2_end')
-// DexExpectWatchValue('test2_b', 2, from_line='test2_start', to_line='test2_end')
-// DexExpectWatchValue('test2_result', 4, from_line='test2_start', to_line='test2_end')
+// DexExpectWatchValue('test2_a', 1, from_line=ref('test2_start'), to_line=ref('test2_end'))
+// DexExpectWatchValue('test2_b', 2, from_line=ref('test2_start'), to_line=ref('test2_end'))
+// DexExpectWatchValue('test2_result', 4, from_line=ref('test2_start'), to_line=ref('test2_end'))
 
 __attribute__((optnone))
 int test3(int test3_a, int test3_b) {
   int test3_temp1 = 0, test3_temp2 = 0;
   // DexLabel('test3_start')
   test3_temp1 = test3_a + 5;   // DexExpectStepOrder(5)
   test3_temp2 = test3_b + 5;   // DexExpectStepOrder(6)
   if (test3_temp1 > test3_temp2) { // DexExpectStepOrder(7)
     test3_temp1 *= test3_temp2;    // DexUnreachable()
   }
   return test3_temp1; // DexExpectStepOrder(8)
   // DexLabel('test3_end')
 }
-// DexExpectWatchValue('test3_a', 5, from_line='test3_start', to_line='test3_end')
-// DexExpectWatchValue('test3_b', 6, from_line='test3_start', to_line='test3_end')
-// DexExpectWatchValue('test3_temp1', 0, 10, from_line='test3_start', to_line='test3_end')
-// DexExpectWatchValue('test3_temp2', 0, 11, from_line='test3_start', to_line='test3_end')
+// DexExpectWatchValue('test3_a', 5, from_line=ref('test3_start'), to_line=ref('test3_end'))
+// DexExpectWatchValue('test3_b', 6, from_line=ref('test3_start'), to_line=ref('test3_end'))
+// DexExpectWatchValue('test3_temp1', 0, 10, from_line=ref('test3_start'), to_line=ref('test3_end'))
+// DexExpectWatchValue('test3_temp2', 0, 11, from_line=ref('test3_start'), to_line=ref('test3_end'))
 
 unsigned num_iterations = 4;
 
 __attribute__((optnone))
 int test4(int test4_a, int test4_b) {
   int val1 = 0, val2 = 0;
   // DexLabel('test4_start')
 
   val1 = (test4_a > test4_b) ? test4_a : test4_b; // DexExpectStepOrder(9)
   val2 = val1;
   val2 += val1; // DexExpectStepOrder(10)
 
   for (unsigned i=0; i != num_iterations; ++i) { // DexExpectStepOrder(11, 13, 15, 17, 19)
     val1--;
     val2 += i;
     if (val2 % 2 == 0) // DexExpectStepOrder(12, 14, 16, 18)
       val2 /= 2;
   }
 
   return (val1 > val2) ? val2 : val1; // DexExpectStepOrder(20)
   // DexLabel('test4_end')
 }
-// DexExpectWatchValue('test4_a', 1, from_line='test4_start', to_line='test4_end')
-// DexExpectWatchValue('test4_b', 9, from_line='test4_start', to_line='test4_end')
-// DexExpectWatchValue('val1', 0, 9, 8, 7, 6, 5, from_line='test4_start', to_line='test4_end')
-// DexExpectWatchValue('val2', 0, 9, 18, 9, 10, 5, 7, 10, 5, 9, from_line='test4_start', to_line='test4_end')
+// DexExpectWatchValue('test4_a', 1, from_line=ref('test4_start'), to_line=ref('test4_end'))
+// DexExpectWatchValue('test4_b', 9, from_line=ref('test4_start'), to_line=ref('test4_end'))
+// DexExpectWatchValue('val1', 0, 9, 8, 7, 6, 5, from_line=ref('test4_start'), to_line=ref('test4_end'))
+// DexExpectWatchValue('val2', 0, 9, 18, 9, 10, 5, 7, 10, 5, 9, from_line=ref('test4_start'), to_line=ref('test4_end'))
 
 __attribute__((optnone))
 int test5(int test5_val) {
   int c = 1;      // DexExpectStepOrder(21)
   // DexLabel('test5_start')
   if (test5_val)  // DexExpectStepOrder(22)
     c = 5;        // DexExpectStepOrder(23)
   return c ? test5_val : test5_val; // DexExpectStepOrder(24)
   // DexLabel('test5_end')
 }
-// DexExpectWatchValue('test5_val', 7, from_line='test5_start', to_line='test5_end')
-// DexExpectWatchValue('c', 1, 5, from_line='test5_start', to_line='test5_end')
+// DexExpectWatchValue('test5_val', 7, from_line=ref('test5_start'), to_line=ref('test5_end'))
+// DexExpectWatchValue('c', 1, 5, from_line=ref('test5_start'), to_line=ref('test5_end'))
 
 int main() {
   int main_result = 0;
   // DexLabel('main_start')
   main_result = test1(3,4);
   main_result += test2(1,2);
   main_result += test3(5,6);
   main_result += test4(1,9);
   main_result += test5(7);
   return main_result;
   // DexLabel('main_end')
 }
-// DexExpectWatchValue('main_result', 0, 7, 11, 21, 26, 33, from_line='main_start', to_line='main_end')
+// DexExpectWatchValue('main_result', 0, 7, 11, 21, 26, 33, from_line=ref('main_start'), to_line=ref('main_end'))

debuginfo-tests/dexter-tests/optnone-struct-and-methods.cpp

void setOtherData() {
     setSomeData2(A_VALUE, B_VALUE);
     getOtherData()->a.long_ptr = &a_global_ptr[0];
   }
 
   __attribute__((optnone))
   A() {
     __builtin_memset(this, 0xFF, sizeof(*this));
   } //DexLabel('break_0')
-  // DexExpectWatchValue('a', '-1', on_line='break_0')
+  // DexExpectWatchValue('a', '-1', on_line=ref('break_0'))
   //// Check b is NaN by comparing it to itself.
-  // DexExpectWatchValue('this->b == this->b', 'false', on_line='break_0')
-  // DexExpectWatchValue('_data.a.raw_ptr == -1', 'true', on_line='break_0')
-  // DexExpectWatchValue('_data.a.float_ptr == -1', 'true', on_line='break_0')
-  // DexExpectWatchValue('_data.a.float_ptr == -1', 'true', on_line='break_0')
-  // DexExpectWatchValue('a_global_ptr[0]', 0xcafebabe, on_line='break_0')
-  // DexExpectWatchValue('a_global_ptr[1]', 0xfeedbeef, on_line='break_0')
+  // DexExpectWatchValue('this->b == this->b', 'false', on_line=ref('break_0'))
+  // DexExpectWatchValue('_data.a.raw_ptr == -1', 'true', on_line=ref('break_0'))
+  // DexExpectWatchValue('_data.a.float_ptr == -1', 'true', on_line=ref('break_0'))
+  // DexExpectWatchValue('_data.a.float_ptr == -1', 'true', on_line=ref('break_0'))
+  // DexExpectWatchValue('a_global_ptr[0]', 0xcafebabe, on_line=ref('break_0'))
+  // DexExpectWatchValue('a_global_ptr[1]', 0xfeedbeef, on_line=ref('break_0'))
 
   __attribute__((optnone))
   ~A() {
     *getOtherData()->a.long_ptr = 0xADDF00DL;
   } //DexLabel('break_1')
-  // DexExpectWatchValue('_data.a.raw_ptr == a_global_ptr', 'true', on_line='break_1')
-  // DexExpectWatchValue('a_global_ptr[0]', 0xaddf00d, on_line='break_1')
+  // DexExpectWatchValue('_data.a.raw_ptr == a_global_ptr', 'true', on_line=ref('break_1'))
+  // DexExpectWatchValue('a_global_ptr[0]', 0xaddf00d, on_line=ref('break_1'))
 
   __attribute__((optnone))
   long getData() {
     setSomeData1(B_VALUE, A_VALUE);
     setOtherData();
     return getOtherData()->a.long_ptr[1]; //DexLabel('break_2')
   }
-  // DexExpectWatchValue('_data.b.other_b', 'B_VALUE', on_line='break_2')
-  // DexExpectWatchValue('_data.b.other_other_b', 'A_VALUE', on_line='break_2')
+  // DexExpectWatchValue('_data.b.other_b', 'B_VALUE', on_line=ref('break_2'))
+  // DexExpectWatchValue('_data.b.other_other_b', 'A_VALUE', on_line=ref('break_2'))
 };
 
 } // anonymous namespace
 
 int main() {
   int result = 0;
   {
     A a;
     result = a.getData();
   }
   return result;
 }

debuginfo-tests/dexter-tests/optnone-vectors-and-functions.cpp

 
 template<typename T>
 __attribute__((optnone))
 T test1(T x, T y) {
   T tmp = x + y; // DexLabel('break_0')
   T tmp2 = tmp + y;
   return tmp; // DexLabel('break_1')
 }
-// DexLimitSteps('1', '1', from_line='break_0', to_line='break_1')
+// DexLimitSteps('1', '1', from_line=ref('break_0'), to_line=ref('break_1'))
 //// FIXME: gdb can print this but lldb cannot. Perhaps PR42920?
-//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::NumElements', 4, on_line='break_0')
-//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::UnusedField', 0xdeadbeef, on_line='break_0')
-//   DexExpectWatchValue('x[0]', 1, on_line='break_0')
-//   DexExpectWatchValue('x[1]', 2, on_line='break_0')
-//   DexExpectWatchValue('x[2]', 3, on_line='break_0')
-//   DexExpectWatchValue('x[3]', 4, on_line='break_0')
-//   DexExpectWatchValue('y[0]', 5, on_line='break_0')
-//   DexExpectWatchValue('y[1]', 6, on_line='break_0')
-//   DexExpectWatchValue('y[2]', 7, on_line='break_0')
-//   DexExpectWatchValue('y[3]', 8, on_line='break_0')
-//   DexExpectWatchValue('tmp[0]', 6, on_line='break_1')
-//   DexExpectWatchValue('tmp[1]', 8, on_line='break_1')
-//   DexExpectWatchValue('tmp[2]', 10, on_line='break_1')
-//   DexExpectWatchValue('tmp[3]', 12, on_line='break_1')
-//   DexExpectWatchValue('tmp2[0]', 11, on_line='break_1')
-//   DexExpectWatchValue('tmp2[1]', 14, on_line='break_1')
-//   DexExpectWatchValue('tmp2[2]', 17, on_line='break_1')
-//   DexExpectWatchValue('tmp2[3]', 20, on_line='break_1')
+//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::NumElements', 4, on_line=ref('break_0'))
+//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::UnusedField', 0xdeadbeef, on_line=ref('break_0'))
+//   DexExpectWatchValue('x[0]', 1, on_line=ref('break_0'))
+//   DexExpectWatchValue('x[1]', 2, on_line=ref('break_0'))
+//   DexExpectWatchValue('x[2]', 3, on_line=ref('break_0'))
+//   DexExpectWatchValue('x[3]', 4, on_line=ref('break_0'))
+//   DexExpectWatchValue('y[0]', 5, on_line=ref('break_0'))
+//   DexExpectWatchValue('y[1]', 6, on_line=ref('break_0'))
+//   DexExpectWatchValue('y[2]', 7, on_line=ref('break_0'))
+//   DexExpectWatchValue('y[3]', 8, on_line=ref('break_0'))
+//   DexExpectWatchValue('tmp[0]', 6, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp[1]', 8, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp[2]', 10, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp[3]', 12, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp2[0]', 11, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp2[1]', 14, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp2[2]', 17, on_line=ref('break_1'))
+//   DexExpectWatchValue('tmp2[3]', 20, on_line=ref('break_1'))
 
 template<typename T>
 __attribute__((optnone))
 T test2(T x, T y) {
   T tmp = x;
   int break_2 = 0; // DexLabel('break_2')
   for (unsigned i = 0; i != TypeTraits<T>::NumElements; ++i) {
     tmp <<= 1; // DexLabel('break_3')
     tmp |= y;
   }
 
   tmp[0] >>= TypeTraits<T>::MysteryNumber;
   return tmp; // DexLabel('break_5')
 }
-// DexLimitSteps('1', '1', on_line='break_2')
-//   DexExpectWatchValue('x[0]', 6, on_line='break_2')
-//   DexExpectWatchValue('x[1]', 8, on_line='break_2')
-//   DexExpectWatchValue('x[2]', 10, on_line='break_2')
-//   DexExpectWatchValue('x[3]', 12, on_line='break_2')
-//   DexExpectWatchValue('y[0]', 5, on_line='break_2')
-//   DexExpectWatchValue('y[1]', 6, on_line='break_2')
-//   DexExpectWatchValue('y[2]', 7, on_line='break_2')
-//   DexExpectWatchValue('y[3]', 8, on_line='break_2')
-//   DexExpectWatchValue('tmp[0]', 6, on_line='break_2')
-//   DexExpectWatchValue('tmp[1]', 8, on_line='break_2')
-//   DexExpectWatchValue('tmp[2]', 10, on_line='break_2')
-//   DexExpectWatchValue('tmp[3]', 12, on_line='break_2')
-// DexLimitSteps('i', 3, on_line='break_3')
-//   DexExpectWatchValue('tmp[0]', 63, on_line='break_3')
-//   DexExpectWatchValue('tmp[1]', 94, on_line='break_3')
-//   DexExpectWatchValue('tmp[2]', 95, on_line='break_3')
-//   DexExpectWatchValue('tmp[3]', 120, on_line='break_3')
-// DexLimitSteps('i', 3, on_line='break_5')
-//   DexExpectWatchValue('tmp[0]', 15, on_line='break_5')
+// DexLimitSteps('1', '1', on_line=ref('break_2'))
+//   DexExpectWatchValue('x[0]', 6, on_line=ref('break_2'))
+//   DexExpectWatchValue('x[1]', 8, on_line=ref('break_2'))
+//   DexExpectWatchValue('x[2]', 10, on_line=ref('break_2'))
+//   DexExpectWatchValue('x[3]', 12, on_line=ref('break_2'))
+//   DexExpectWatchValue('y[0]', 5, on_line=ref('break_2'))
+//   DexExpectWatchValue('y[1]', 6, on_line=ref('break_2'))
+//   DexExpectWatchValue('y[2]', 7, on_line=ref('break_2'))
+//   DexExpectWatchValue('y[3]', 8, on_line=ref('break_2'))
+//   DexExpectWatchValue('tmp[0]', 6, on_line=ref('break_2'))
+//   DexExpectWatchValue('tmp[1]', 8, on_line=ref('break_2'))
+//   DexExpectWatchValue('tmp[2]', 10, on_line=ref('break_2'))
+//   DexExpectWatchValue('tmp[3]', 12, on_line=ref('break_2'))
+// DexLimitSteps('i', 3, on_line=ref('break_3'))
+//   DexExpectWatchValue('tmp[0]', 63, on_line=ref('break_3'))
+//   DexExpectWatchValue('tmp[1]', 94, on_line=ref('break_3'))
+//   DexExpectWatchValue('tmp[2]', 95, on_line=ref('break_3'))
+//   DexExpectWatchValue('tmp[3]', 120, on_line=ref('break_3'))
+// DexLimitSteps('i', 3, on_line=ref('break_5'))
+//   DexExpectWatchValue('tmp[0]', 15, on_line=ref('break_5'))
 
 template<typename T>
 __attribute__((optnone))
 T test3(T InVec) {
   T result;
   for (unsigned i=0; i != TypeTraits<T>::NumElements; ++i)
     result[i] = InVec[i]; // DexLabel('break_6')
   return result; // DexLabel('break_7')
 }
-// DexLimitSteps('i', '3', from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('InVec[0]', 15, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('InVec[1]', 190, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('InVec[2]', 191, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('InVec[3]', 248, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('result[0]', 15, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('result[1]', 190, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('result[2]', 191, from_line='break_6', to_line='break_7')
-//   DexExpectWatchValue('result[3]', 248, on_line='break_7')
+// DexLimitSteps('i', '3', from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('InVec[0]', 15, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('InVec[1]', 190, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('InVec[2]', 191, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('InVec[3]', 248, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('result[0]', 15, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('result[1]', 190, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('result[2]', 191, from_line=ref('break_6'), to_line=ref('break_7'))
+//   DexExpectWatchValue('result[3]', 248, on_line=ref('break_7'))
 
 template<typename T>
 __attribute__((optnone))
 T test4(T x, T y) {
   for (unsigned i=0; i != TypeTraits<T>::NumElements; ++i)
     x[i] = (x[i] > y[i])? x[i] : y[i] + TypeTraits<T>::MysteryNumber; // DexLabel('break_11')
   return x; // DexLabel('break_12')
 }
-// DexLimitSteps('1', '1', from_line='break_11', to_line='break_12')
+// DexLimitSteps('1', '1', from_line=ref('break_11'), to_line=ref('break_12'))
 //// FIXME: lldb won't print this but gdb unexpectedly says it's optimized out, even at O0.
-//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::MysteryNumber', 3, on_line='break_11')
-//   DexExpectWatchValue('i', 0, 1, 2, 3, on_line='break_11')
-//   DexExpectWatchValue('x[0]', 1, 8, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('x[1]', 2, 9, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('x[2]', 3, 10, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('x[3]', 4, 11, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('y[0]', 5, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('y[1]', 6, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('y[2]', 7, from_line='break_11', to_line='break_12')
-//   DexExpectWatchValue('y[3]', 8, from_line='break_11', to_line='break_12')
+//     \DexExpectWatchValue('TypeTraits<int __attribute__((ext_vector_type(4)))>::MysteryNumber', 3, on_line=ref('break_11'))
+//   DexExpectWatchValue('i', 0, 1, 2, 3, on_line=ref('break_11'))
+//   DexExpectWatchValue('x[0]', 1, 8, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('x[1]', 2, 9, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('x[2]', 3, 10, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('x[3]', 4, 11, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('y[0]', 5, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('y[1]', 6, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('y[2]', 7, from_line=ref('break_11'), to_line=ref('break_12'))
+//   DexExpectWatchValue('y[3]', 8, from_line=ref('break_11'), to_line=ref('break_12'))
 
 int main() {
   int4 a = (int4){1,2,3,4};
   int4 b = (int4){5,6,7,8};
 
   int4 tmp = test1(a,b);
   tmp = test2(tmp,b);
   tmp = test3(tmp);
   tmp += test4(a,b);
   return tmp[0];
 }

debuginfo-tests/dexter-tests/realigned-frame.cpp

void Foo::bar(int *a, int *b, double *c) {
   *c += *a + *b; // DexLabel('in_bar')
 }
 int main() {
   Foo o;
   o.foo();
 }
 /*
 DexExpectProgramState({'frames':[
-    {'function': 'Foo::bar', 'location' : {'lineno' : 'in_bar'} },
+    {'function': 'Foo::bar', 'location' : {'lineno' : ref('in_bar')} },
     {'function': 'Foo::foo',
      'watches' : {
        'a' : '1',
        'b' : '2',
        'force_alignment' : '0.42'
      }
     }
 ]})
 */

debuginfo-tests/dexter-tests/stack-var.c

 // REQUIRES: lldb
 // UNSUPPORTED: system-windows
 //
 // RUN: %dexter --fail-lt 1.0 -w \
 // RUN:     --builder clang-c --debugger 'lldb' --cflags "-O -glldb" -- %s
 
 void __attribute__((noinline, optnone)) bar(int *test) {}
 int main() {
   int test;
   test = 23;
   bar(&test); // DexLabel('before_bar')
   return test; // DexLabel('after_bar')
 }
 
-// DexExpectWatchValue('test', '23', on_line='before_bar')
-// DexExpectWatchValue('test', '23', on_line='after_bar')
+// DexExpectWatchValue('test', '23', on_line=ref('before_bar'))
+// DexExpectWatchValue('test', '23', on_line=ref('after_bar'))
 

debuginfo-tests/dexter-tests/vla.c

void init_vla(int size) {
   vla[0] = size; // DexLabel('end_init')
 }
 
 int main(int argc, const char **argv) {
   init_vla(23);
   return 0;
 }
 
-// DexExpectWatchValue('vla[0]', '23', on_line='end_init')
-// DexExpectWatchValue('vla[1]', '22', on_line='end_init')
+// DexExpectWatchValue('vla[0]', '23', on_line=ref('end_init'))
+// DexExpectWatchValue('vla[1]', '22', on_line=ref('end_init'))
 

debuginfo-tests/dexter/feature_tests/commands/penalty/expect_program_state.cpp

int main()
     return GCD(111, 259);
 }
 
 /*
 DexExpectProgramState({
     'frames': [
         {
             'location': {
-                'lineno': 'check'
+                'lineno': ref('check')
             },
             'watches': {
                 'lhs': '0', 'rhs': '0'
             }
         },
     ]
 })
 */

debuginfo-tests/dexter/feature_tests/commands/penalty/expect_watch_type.cpp

int main() {
   auto staticallyDoubledDouble = Doubled<double>::static_doubler(5.5);
   return int(double(myInt.GetVal())
          + double(staticallyDoubledInt)
          + myDouble.GetVal()
          + staticallyDoubledDouble); // DexLabel('main_end')
 }
 
 
-// DexExpectWatchType('m_member', 'int', 'double', from_line='gv_start', to_line='gv_end')
+// DexExpectWatchType('m_member', 'int', 'double', from_line=ref('gv_start'), to_line=ref('gv_end'))
 
 // THIS COMMAND should create a penalty for a missing type 'const double' and unexpected type 'const double &'
-// DexExpectWatchType('to_double', 'const double', 'const int &', from_line='sd_start', to_line='sd_end')
+// DexExpectWatchType('to_double', 'const double', 'const int &', from_line=ref('sd_start'), to_line=ref('sd_end'))
 
-// DexExpectWatchType('myInt', 'Doubled<int>', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('myDouble', 'Doubled<double>', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('staticallyDoubledInt', 'int', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('staticallyDoubledDouble', 'double', from_line='main_start', to_line='main_end')
+// DexExpectWatchType('myInt', 'Doubled<int>', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('myDouble', 'Doubled<double>', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('staticallyDoubledInt', 'int', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('staticallyDoubledDouble', 'double', from_line=ref('main_start'), to_line=ref('main_end'))
 

debuginfo-tests/dexter/feature_tests/commands/penalty/expect_watch_value.cpp

 
 int main()
 {
     for (int i = 0; i < 3; ++i)
         int a = i; // DexLabel('loop')
     return 0;  // DexLabel('ret')
 }
 
-// DexExpectWatchValue('i', '0', '1', '2', on_line='loop')
-// DexExpectWatchValue('i', '3', on_line='ret')
+// DexExpectWatchValue('i', '0', '1', '2', on_line=ref('loop'))
+// DexExpectWatchValue('i', '3', on_line=ref('ret'))
 // ---------------------^ out of scope

debuginfo-tests/dexter/feature_tests/commands/perfect/expect_program_state.cpp

int main()
     return GCD(111, 259);
 }
 
 /*
 DexExpectProgramState({
     'frames': [
         {
             'location': {
-                'lineno': 'check'
+                'lineno': ref('check')
             },
             'watches': {
                 'lhs': '37', 'rhs': '0'
             }
         },
         {
             'watches': {
                 'lhs': {'value': '111'}, 'rhs': {'value': '37'}

debuginfo-tests/dexter/feature_tests/commands/perfect/expect_watch_type.cpp

int main() {
   auto staticallyDoubledInt = Doubled<int>::static_doubler(5);
   auto staticallyDoubledDouble = Doubled<double>::static_doubler(5.5);
   return int(double(myInt.GetVal())
          + double(staticallyDoubledInt)
          + myDouble.GetVal()
          + staticallyDoubledDouble); // DexLabel('main_end')
 }
 
-// DexExpectWatchType('m_member', 'int', 'double', from_line='gv_start', to_line='gv_end')
+// DexExpectWatchType('m_member', 'int', 'double', from_line=ref('gv_start'), to_line=ref('gv_end'))
 
-// DexExpectWatchType('to_double', 'const int &', 'const double &', from_line='sd_start', to_line='sd_end')
+// DexExpectWatchType('to_double', 'const int &', 'const double &', from_line=ref('sd_start'), to_line=ref('sd_end'))
 
-// DexExpectWatchType('myInt', 'Doubled<int>', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('myDouble', 'Doubled<double>', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('staticallyDoubledInt', 'int', from_line='main_start', to_line='main_end')
-// DexExpectWatchType('staticallyDoubledDouble', 'double', from_line='main_start', to_line='main_end')
+// DexExpectWatchType('myInt', 'Doubled<int>', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('myDouble', 'Doubled<double>', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('staticallyDoubledInt', 'int', from_line=ref('main_start'), to_line=ref('main_end'))
+// DexExpectWatchType('staticallyDoubledDouble', 'double', from_line=ref('main_start'), to_line=ref('main_end'))
 

debuginfo-tests/dexter/feature_tests/commands/perfect/expect_watch_value.cpp

 }
 
 int main()
 {
     return Factorial(8);
 }
 
 /*
-DexExpectWatchValue('n', '8', on_line='entry')
+DexExpectWatchValue('n', '8', on_line=ref('entry'))
 DexExpectWatchValue('i',
                     '1', '2', '3', '4', '5', '6', '7', '8',
-                    on_line='loop')
+                    on_line=ref('loop'))
 
 DexExpectWatchValue('fac',
                     '1', '2', '6', '24', '120', '720', '5040',
-                     on_line='loop')
+                     on_line=ref('loop'))
 
-DexExpectWatchValue('n', '8', on_line='loop')
-DexExpectWatchValue('fac', '40320', on_line='ret')
-DexExpectWatchValue('n', '8', on_line='ret')
+DexExpectWatchValue('n', '8', on_line=ref('loop'))
+DexExpectWatchValue('fac', '40320', on_line=ref('ret'))
+DexExpectWatchValue('n', '8', on_line=ref('ret'))
 */

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_check_json_step_count.cpp

 int main() {
   int result = 0;
   for(int ix = 0; ix != 10; ++ix) {
     int index = ix;
     result += index; // DexLabel('check')
   }
 }
 
-// DexExpectWatchValue('index', 2, 7, 9, on_line='check')
-// DexLimitSteps('ix', 2, 7, 9, on_line='check')
+// DexExpectWatchValue('index', 2, 7, 9, on_line=ref('check'))
+// DexLimitSteps('ix', 2, 7, 9, on_line=ref('check'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_loop.cpp

int main(const int argc, const char * argv[]) {
   unsigned int sum = 1;
   for(unsigned int ix = 0; ix != 5; ++ix) {
     unsigned thing_to_add = ix + ix - ix;   // DexLabel('start')
     sum += ix;                              // DexLabel('end')
   }
   return sum;
 }
 
-// DexLimitSteps('ix', 0, 3, from_line='start', to_line='end')
-// DexExpectWatchValue('ix', 0, 3, from_line='start', to_line='end')
+// DexLimitSteps('ix', 0, 3, from_line=ref('start'), to_line=ref('end'))
+// DexExpectWatchValue('ix', 0, 3, from_line=ref('start'), to_line=ref('end'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_expect_value.cpp

 // Purpose:
 //      Ensure that limited stepping breaks for all expected values.
 //
 // REQUIRES: system-linux
 //
 // RUN: %dexter_regression_test -- %s | FileCheck %s
 // CHECK: limit_steps_expect_value.cpp
 
 int main() {
   int i = 0;
   i = 1;    // DexLabel('from')
   i = 2;
   i = 3;
   return 0; // DexLabel('long_range')
 }
 
-// DexLimitSteps('i', '0', from_line='from', to_line='long_range')
-// DexExpectWatchValue('i', 0, 1, 2, 3, from_line='from', to_line='long_range')
+// DexLimitSteps('i', '0', from_line=ref('from'), to_line=ref('long_range'))
+// DexExpectWatchValue('i', 0, 1, 2, 3, from_line=ref('from'), to_line=ref('long_range'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_line_mismatch.cpp

int main() {
   for (; i < 2; i++) {
     // DexLabel('from')
     int x = i;
   }
   int ret = 0;
   return ret; // DexLabel('to')
 }
 
-// DexLimitSteps('1', '1', from_line='from', to_line='to')
-// DexExpectWatchValue('i', 0, 1, 2, from_line='from', to_line='to')
+// DexLimitSteps('1', '1', from_line=ref('from'), to_line=ref('to'))
+// DexExpectWatchValue('i', 0, 1, 2, from_line=ref('from'), to_line=ref('to'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_overlapping_ranges.cpp

else if (ix == 2) {
       val1 = ix;             // DexLabel('val2_check')
       placeholder=val1+val2; // DexLabel('val2_check_to')
     }
     placeholder=val1+val2;   // DexLabel('to')
   }
   return val1 + val2;
 }
 
-// DexExpectWatchValue('ix', 0, 2, 5, from_line='from', to_line='to')
-// DexExpectWatchValue('val1', 0, from_line='val1_check', to_line='val1_check_to')
-// DexExpectWatchValue('val2', 2, from_line='val2_check', to_line='val2_check_to')
+// DexExpectWatchValue('ix', 0, 2, 5, from_line=ref('from'), to_line=ref('to'))
+// DexExpectWatchValue('val1', 0, from_line=ref('val1_check'), to_line=ref('val1_check_to'))
+// DexExpectWatchValue('val2', 2, from_line=ref('val2_check'), to_line=ref('val2_check_to'))
 
-// DexLimitSteps('ix', 5, from_line='from', to_line='to')
-// DexLimitSteps('val1', 0, from_line='val1_check', to_line='val1_check_to')
-// DexLimitSteps('val2', 2, from_line='val2_check', to_line='val2_check_to')
+// DexLimitSteps('ix', 5, from_line=ref('from'), to_line=ref('to'))
+// DexLimitSteps('val1', 0, from_line=ref('val1_check'), to_line=ref('val1_check_to'))
+// DexLimitSteps('val2', 2, from_line=ref('val2_check'), to_line=ref('val2_check_to'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/limit_steps_same_line_conditional.cpp

for(int ix = 0; ix != 4; ++ix) {
     placeholder = ix;    // DexLabel('from')
     placeholder = ix;
     val1 += 2;           // DexLabel('to')
     placeholder = ix;    // DexLabel('extended_to')
   }
   return val1 + placeholder;
 }
 
-// DexExpectWatchValue('val1', 0, 1, 3, from_line='from', to_line='extended_to')
+// DexExpectWatchValue('val1', 0, 1, 3, from_line=ref('from'), to_line=ref('extended_to'))
 
-// DexLimitSteps('ix', 0, from_line='from', to_line='to')
-// DexLimitSteps('ix', 1, from_line='from', to_line='extended_to')
+// DexLimitSteps('ix', 0, from_line=ref('from'), to_line=ref('to'))
+// DexLimitSteps('ix', 1, from_line=ref('from'), to_line=ref('extended_to'))

debuginfo-tests/dexter/feature_tests/commands/perfect/limit_steps/unconditional.cpp

int main() {
   int test = 0;
   for (test = 1; test < 4; test++) {
     glob += test; // DexLabel('from')
     glob += test; // DexLabel('to')
   }
   return test; // test = 4
 }
 
-// DexLimitSteps(from_line='from', to_line='to')
+// DexLimitSteps(from_line=ref('from'), to_line=ref('to'))
 //// Unconditionally limit dexter's view of the program from line 'from' to
 //// 'to'. Check for test=0, 1, 2 so that the test will fail if dexter sees
 //// test=0 or test=4.
 // DexExpectWatchValue('test', 1, 2, 3)
 

debuginfo-tests/dexter/feature_tests/subtools/test/label_another_line.cpp

 // REQUIRES: lldb
 // UNSUPPORTED: system-windows
 //
 // Purpose:
 //    Check that the optional keyword argument 'on_line' makes a \DexLabel label
 //    that line instead of the line the command is found on.
 //
 // RUN: %dexter_regression_test -- %s | FileCheck %s
 // CHECK: label_another_line.cpp: (1.0000)
 
 int main() {
   int result = 0;
   return result;
 }
 
 // DexLabel('test', on_line=13)
-// DexExpectWatchValue('result', '0', on_line='test')
+// DexExpectWatchValue('result', '0', on_line=ref('test'))

debuginfo-tests/dexter/feature_tests/subtools/test/label_another_line.cpp.rej

+diff a/debuginfo-tests/dexter/feature_tests/subtools/test/label_another_line.cpp b/debuginfo-tests/dexter/feature_tests/subtools/test/label_another_line.cpp  (rejected hunks)
+@@ -11,4 +11,4 @@
+ }
+ 
+ // DexLabel('test', on_line=10)
+-// DexExpectWatchValue('result', '0', on_line=ref('test'))
++// DexExpectWatchValue('result', '0', on_line=ref('test'))

debuginfo-tests/dexter/feature_tests/subtools/test/source-root-dir.cpp

 // REQUIRES: lldb
 // UNSUPPORTED: system-windows
 //
 // RUN: %dexter --fail-lt 1.0 -w \
 // RUN:     --builder 'clang' --debugger 'lldb' \
 // RUN:     --cflags "-O0 -glldb -fdebug-prefix-map=%S=/changed" \
 // RUN:     --source-root-dir=%S -- %s
 
 #include <stdio.h>
 int main() {
   int x = 42;
   printf("hello world: %d\n", x); // DexLabel('check')
 }
 
-// DexExpectWatchValue('x', 42, on_line='check')
+// DexExpectWatchValue('x', 42, on_line=ref('check'))

debuginfo-tests/dexter/feature_tests/subtools/view.cpp

 //
 // # [TODO] This doesn't run if FileCheck fails!
 // RUN: rm -rf %t
 
 int main() {
     int a = 0;
     return 0; //DexLabel('ret')
 }
-// DexExpectWatchValue('a', '0', on_line='ret')
+// DexExpectWatchValue('a', '0', on_line=ref('ret'))