Add a threaded test (harder to check unwinding end)

test/Makefile

@@ -1,19 +1,19 @@
 CXX=g++
-CXXFLAGS=-Wall -Wextra -O0 -g --std=c++14
+CXXFLAGS=-Wall -Wextra -O0 -g --std=c++14 -rdynamic
-CXXLIBS=-ldwarfpp -ldwarf -lelf -lc++fileno -ldwarfinterpret
+CXXLIBS=-ldwarfpp -ldwarf -lelf -lc++fileno -ldwarfinterpret -ldl -lpthread
 CXXDIRS=-I../include -L../lib
 
+CPP_FILES := $(shell ls *.cpp)
+BINS := $(CPP_FILES:.cpp=.bin)
+
 
 ###############################################################################
 
-all: $(TARGET)
+all: $(BINS)
 
 %.bin: %.o
 	$(CXX) $(CXXFLAGS) $(CXXDIRS) $(CXXLIBS) $< -o "$@"
 
-dump_my_stack.bin: dump_my_stack.o
-	$(CXX) $(CXXFLAGS) $(CXXDIRS) $(CXXLIBS) -ldl -rdynamic $< -o "$@"
-
 %.o: %.cpp
 	$(CXX) $(CXXFLAGS) $(CXXDIRS) -c "$<" -o "$@"
 

test/dump_my_threads.cpp

@@ -0,0 +1,70 @@
+#include <cstdio>
+#include <dlfcn.h>
+#include <DwarfInterpret.hpp>
+#include <thread>
+
+using namespace std;
+
+volatile int optim_stopper = 0;
+
+void dump_my_stack(int thread_id) {
+    DwarfInterpret& dw = DwarfInterpret::acquire();
+
+    DwarfInterpret::UnwindContext unw_context =
+        DwarfInterpret::get_current_unwind_context();
+    MemoryMap mmap;
+
+    while(true) {
+        Dl_info dl_inf;
+        int dl_rc = dladdr((void *) unw_context.rip, &dl_inf);
+
+        printf("[%d] >> PC = %lX ", thread_id, unw_context.rip);
+        MemoryMap::MapEntry cur_map_entry =
+            mmap[mmap.id_of_address(unw_context.rip)];
+        uintptr_t inelf_pc = unw_context.rip
+            - cur_map_entry.mem_region.begin + cur_map_entry.offset;
+
+        printf("(in ELF: 0x%lX, func %s, path %s) <<\n",
+                inelf_pc,
+                (dl_rc && dl_inf.dli_sname) ? dl_inf.dli_sname : "(no symbol)",
+                cur_map_entry.pathname.c_str());
+        fflush(stdout);
+        try {
+        unw_context = dw.unwind_context(unw_context);
+        } catch(...) {
+            // Assume we're reached _start
+            return;
+        }
+    }
+}
+
+void fill_my_stack(int stack_depth, int thread_id) {
+    if(stack_depth == 0) {
+        dump_my_stack(thread_id);
+        return;
+    }
+
+    std::this_thread::sleep_for(100ms);
+    fill_my_stack(stack_depth - 1, thread_id);
+}
+
+int main(int argc, char** argv) {
+    MemoryMap mmap;
+    cout << "Dumping memory map… (" << mmap.size() << " entries)" << endl;
+    for(const auto& entry: mmap) {
+        entry.dump(cout);
+    }
+    cout << "End memory map" << endl;
+    int stack_depth = 5;
+    if(argc >= 2)
+        stack_depth = atoi(argv[1]);
+
+    fill_my_stack(1, 0);
+
+    std::thread th_stackwalk1(fill_my_stack, stack_depth, 1);
+    std::thread th_stackwalk2(fill_my_stack, stack_depth - 1, 2);
+    th_stackwalk1.join();
+    th_stackwalk2.join();
+
+    return 0;
+}