RegisterContextLLDB: Push CFA value on DWARF stack when evaluating register expressions

[labath]

Summary

This behavior is specified in the Section 6.4.2.3 (Register Rule
instructions) of the DWARF4 spec. We were not doing that, which meant
that any register rule which was relying on the cfa value being there
was not evaluated correctly (it was aborted due to "out of bounds"
access).

I'm not sure how come this wasn't noticed before, but I guess this has
something to do with the fact that dwarf unwind expressions are not used
very often, and when they are, the situation is so complicated that the
CFA is of no use. I noticed this when I started emitting dwarf
expressions for the unwind information present in breakpad symbol files.

[clayborg]

Got errors trying to compile this .s file on mac:

$ ~/Documents/src/lldb/svn/lldb/llvm-build/Release+Asserts/x86_64/bin/clang foo.s -o foo.o
foo.s:3:9: error: unknown directive
        .type bar, @function
        ^
foo.s:11:9: error: unknown directive
        .size bar, .-bar
        ^
foo.s:13:9: error: unknown directive
        .type foo, @function
        ^
foo.s:25:9: error: unknown directive
        .size foo, .-foo
        ^
foo.s:27:9: error: unknown directive
        .type main, @function
        ^
foo.s:49:9: error: unknown directive
        .size main, .-main

[labath]

In D61018#1475553, @clayborg wrote:

Got errors trying to compile this .s file on mac:

$ ~/Documents/src/lldb/svn/lldb/llvm-build/Release+Asserts/x86_64/bin/clang foo.s -o foo.o
foo.s:3:9: error: unknown directive
        .type bar, @function
        ^
foo.s:11:9: error: unknown directive
        .size bar, .-bar
        ^
foo.s:13:9: error: unknown directive
        .type foo, @function
        ^
foo.s:25:9: error: unknown directive
        .size foo, .-foo
        ^
foo.s:27:9: error: unknown directive
        .type main, @function
        ^
foo.s:49:9: error: unknown directive
        .size main, .-main

Yeah, that test is linux-only (technically, other elf platforms may work too). I am not aware of any way to generate eh_frame entries with this kind of content except by hand-written assembly, and assembly is not really cross-platform.

If you just want to look at the resulting binary, you can add -target x86_64-pc-linux -c to the clang invocation, but that of course still won't run on a mac.

[labath]

Actually, it seems it may be possible to tweak this asm so that it can run on a mac too (windows support unlikely). I'll try to post an updated version soon.

[labath]

This is the version that should at least compile on a mac (it turns out asm is more portable than I expected). I am still building lldb to see if the test will pass.

[labath]

Indeed the test passes on a mac with just a single linker warning saying it could not create compact unwind info because the %rip save address is weird, but that is not surprising.

[labath]

Jason, could you take a quick look at this. I don't expect this to be too contentious...

lit/Unwind/Inputs/call-asm.c

+int asm_main() asm("asm_main");
+
+int main() { return asm_main(); }

lit/Unwind/Inputs/eh-frame-dwarf-unwind.s

+        .text
+        .globl  bar
+bar:
+        .cfi_startproc
+        leal    (%edi, %edi), %eax
+        ret
+        .cfi_endproc
+
+        .globl  foo
+foo:
+        .cfi_startproc
+        .cfi_escape 0x16, 0x10, 0x06, 0x38, 0x1c, 0x06, 0x08, 0x47, 0x1c
+        call    bar
+        addl    $1, %eax
+        popq    %rdi
+        subq    $0x47, %rdi
+        jmp     *%rdi # Return
+        .cfi_endproc
+
+        .globl  asm_main
+asm_main:
+        .cfi_startproc
+        pushq   %rbp
+        .cfi_def_cfa_offset 16
+        .cfi_offset 6, -16
+        movq    %rsp, %rbp
+        .cfi_def_cfa_register 6
+        movl    $47, %edi
+
+        # Non-standard calling convention. The real return address must be
+        # decremented by 0x47.
+        leaq    0x47+1f(%rip), %rax
+        pushq   %rax
+        jmp     foo # call
+1:
+        popq    %rbp
+        .cfi_def_cfa 7, 8
+        ret
+        .cfi_endproc

lit/Unwind/eh-frame-dwarf-unwind.test

+# Test handing of dwarf expressions specifying the location of registers, if
+# those expressions refer to the frame's CFA value.
+
+# REQUIRES: target-x86_64, native
+
+# RUN: %clang %p/Inputs/call-asm.c %p/Inputs/eh-frame-dwarf-unwind.s -o %t
+# RUN: %lldb %t -s %s -o exit | FileCheck %s
+
+breakpoint set -n bar
+# CHECK: Breakpoint 1: where = {{.*}}`bar
+
+process launch
+# CHECK: stop reason = breakpoint 1.1
+
+thread backtrace
+# CHECK: frame #0: {{.*}}`bar
+# CHECK: frame #1: {{.*}}`foo + 5
+# CHECK: frame #2: {{.*}}`asm_main + 22
+
+target modules show-unwind -n foo
+# CHECK: eh_frame UnwindPlan:
+# CHECK: row[0]: 0: CFA=rsp +8 => rip=DW_OP_lit8 , DW_OP_minus , DW_OP_deref , DW_OP_const1u 0x47, DW_OP_minus

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

if (unwindplan_regloc.IsDWARFExpression() ||
     DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
                             unwindplan_regloc.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
     DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr, 0,
                               unwindplan_regloc.GetDWARFExpressionLength());
     dwarfexpr.SetRegisterKind(unwindplan_registerkind);
+    Value cfa_val = Scalar(m_cfa);
+    cfa_val.SetValueType(Value::eValueTypeLoadAddress);
     Value result;
     Status error;
-    if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
+    if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
                            &error)) {
       addr_t val;
       val = result.GetScalar().ULongLong();
       if (unwindplan_regloc.IsDWARFExpression()) {
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
         regloc.location.inferred_value = val;
         m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
         UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "