you might not like this pull request ...

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required (VERSION 3.0)
 project (cfg)
 
-add_library(cfg SHARED cfg.cpp cfg_impl.cpp cbr.cpp cti.cpp app.cpp)
+add_library(cfg SHARED cfg.cpp cfg_impl.cpp app.cpp)
 find_package(DynamoRIO REQUIRED)
 configure_DynamoRIO_client(cfg)
 use_DynamoRIO_extension(cfg "drmgr")

Makefile

@@ -0,0 +1,17 @@
+all:
+	mkdir -p build
+	cd build && cmake .. -DDynamoRIO_DIR="$(DYNAMORIO_HOME)/cmake" && make
+
+install: all
+	install -d /usr/local/lib/dynamorio
+	install build/libcfg.so /usr/local/lib/dynamorio
+	install drcfg.sh /usr/local/bin/
+
+save:	all
+	mkdir -p bin/`uname -m`
+	cp -v build/lib*.so bin/`uname -m`
+	-@svn add bin/`uname -m` 2> /dev/null
+	-@svn add bin/`uname -m`/*.so 2> /dev/null
+
+clean:
+	rm -rf build

README.md

@@ -36,6 +36,7 @@ Options for `drcfg` are shown below:
  -no_cbr              [ false]  Don't count conditional branch instructions
  -no_cti              [ false]  Don't count control transfer instructions
  -output              [    ""]  Output results to file
+ -txt                 [ false]  output text instead of json, with many doubles
 ```
 
 # How to Build

app.h

@@ -1,5 +1,11 @@
 #ifndef APP_H_
 #define APP_H_
+#include "dr_api.h"
+#include "drmgr.h"
+#include "droption.h"
+
+extern droption_t<bool> txt;
+extern droption_t<std::string> output;
 
 void app_init(void);
 bool app_should_ignore_tag(void *tag);

cfg.cpp

@@ -18,22 +18,91 @@ static droption_t<bool> no_cti
 (DROPTION_SCOPE_CLIENT, "no_cti", false,
  "Don't count control transfer instructions", "");
 
-static droption_t<std::string> output
+droption_t<std::string> output
 (DROPTION_SCOPE_CLIENT, "output", "",
  "Output results to file", "");
 
+droption_t<bool> txt
+(DROPTION_SCOPE_CLIENT, "txt", false,
+ "Print text output while running instead of json at the end of the run - you will have to take care of the doubles youself", "");
+
+static void *mutex;
+static int tcls_idx;
+static FILE *out = stdout;
+
+typedef struct {
+  void *addr;
+} per_thread_t;
+
+
 void
 dr_exit(void)
 {
-    if (output.get_value() == "")
-        std::cout << std::setw(2) << construct_json() << std::endl;
-    else {
-        std::ofstream ofs(output.get_value());
-        ofs << std::setw(2) << construct_json() << std::endl;
+    if (!txt.get_value()) {
+        if (output.get_value() == "")
+            std::cout << std::hex << std::setw(2) << construct_json() << std::endl;
+        else {
+            std::ofstream ofs(output.get_value());
+            ofs << std::hex << std::setw(2) << construct_json() << std::endl;
+        }
     }
     drmgr_exit();
 }
 
+void 
+event_thread_context_init(void *drcontext, bool new_depth)
+{
+    per_thread_t *data;
+
+    if (new_depth) {
+        data = (per_thread_t *) dr_thread_alloc(drcontext, sizeof(per_thread_t));
+        drmgr_set_cls_field(drcontext, tcls_idx, data);
+    } else {
+        data = (per_thread_t *) drmgr_get_cls_field(drcontext, tcls_idx);
+    }
+    memset(data, 0, sizeof(*data));
+}
+
+void
+event_thread_context_exit(void *drcontext, bool thread_exit)
+{
+    if (thread_exit) {
+        per_thread_t *data = (per_thread_t *) drmgr_get_cls_field(drcontext, tcls_idx);
+        dr_thread_free(drcontext, data, sizeof(per_thread_t));
+        drmgr_set_cls_field(drcontext, tcls_idx, NULL);
+    }
+}
+
+dr_emit_flags_t
+event_app_instruction(void *drcontext, void *tag, instrlist_t *bb, instr_t *instr,
+                      bool for_trace, bool translating, void *user_data)
+{
+    per_thread_t *data = (per_thread_t *) drmgr_get_cls_field(drcontext, tcls_idx);
+    if (data->addr != NULL) {
+        dr_mutex_lock(mutex);
+        if (txt.get_value()) {
+            fprintf(out, "INDIRECT jmp/call from %p to %p\n", data->addr, tag);
+        } else {
+            safe_insert((uintptr_t)data->addr, (uintptr_t)tag);
+        }
+        dr_mutex_unlock(mutex);
+        data->addr = NULL;
+    }
+
+    if (!drmgr_is_last_instr(drcontext, instr))
+        return DR_EMIT_DEFAULT;
+    if (app_should_ignore_tag(tag))
+        return DR_EMIT_DEFAULT;
+
+    if (!no_cbr.get_value() && instr_is_cbr(instr))
+      data->addr = instr_get_app_pc(instr);
+    else if (!no_cti.get_value() && instr_is_cbr(instr))
+      data->addr = instr_get_app_pc(instr);
+
+    if (app_should_ignore_tag(tag))
+        return DR_EMIT_DEFAULT;
+}
+
 DR_EXPORT
 void
 dr_client_main(client_id_t id, int argc, const char *argv[])
@@ -46,9 +115,21 @@ dr_client_main(client_id_t id, int argc, const char *argv[])
 
     app_init();
     drmgr_init();
+
+    if (output.get_value() != "") {
+        if ((out = fopen(output.get_value().c_str(), "w")) == NULL)
+            DR_ASSERT_MSG(false, "can not write -outputfile");
+    }
+
+    mutex = dr_mutex_create();
+    tcls_idx = drmgr_register_cls_field(event_thread_context_init, event_thread_context_exit);
+    DR_ASSERT_MSG(tcls_idx != -1, "memory problems");
+    drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL);
+/*    
     if (!no_cbr.get_value())
         drmgr_register_bb_instrumentation_event(NULL, cbr_event_app_instruction, NULL);
     if (!no_cti.get_value())
         drmgr_register_bb_instrumentation_event(NULL, cti_event_app_instruction, NULL);
+*/
     dr_register_exit_event(dr_exit);
 }

cfg_impl.cpp

@@ -9,18 +9,20 @@ using nlohmann::json;
 
 static droption_t<bool> racy
 (DROPTION_SCOPE_CLIENT, "racy", false,
- "Perform racy hashtable insertion", "");
+ "unused option", "");
 
 static std::unordered_map<uintptr_t, std::unordered_set<uintptr_t>> cbr;
 static std::mutex mtx;
 
 void
 safe_insert(uintptr_t src, uintptr_t trg)
 {
+/*
     if (!racy.get_value()) {
         std::lock_guard<std::mutex> g(mtx);
         cbr[src].insert(trg);
     } else
+*/
         cbr[src].insert(trg);
 }
 
@@ -42,10 +44,12 @@ construct_json_impl()
 json
 construct_json()
 {
+/*
     if (!racy.get_value()) {
         std::lock_guard<std::mutex> g(mtx);
         return construct_json_impl();
     } else
+*/
         return construct_json_impl();
 }
 

cti.cpp

@@ -3,7 +3,10 @@
 #include "cfg_impl.h"
 #include "app.h"
 #include "droption.h"
-
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <iomanip>
 #include <cstdint>
 
 static droption_t<bool> instrument_ret
@@ -14,6 +17,14 @@ static void
 at_cti(uintptr_t src, uintptr_t targ)
 {
     safe_insert(src, targ);
+    if (txt.get_value()) {
+//        if (output.get_value() == "") {
+            std::cout << "INDIRECT jmp/call from " << std::hex << src << " to " << targ << std::endl;
+/*        } else {
+            std::ofstream ofs(output.get_value());
+            ofs << "INDIRECT from " << std::hex << src << " to " << targ << std::endl;
+        }
+*/    }
 }
 
 dr_emit_flags_t

drcfg.sh

@@ -0,0 +1,16 @@
+#/bin/sh
+VER=32
+uname -m 2> /dev/null | grep -q 64 > /dev/null 2>&1 && VER=64
+HELP=yes
+for i in $*; do 
+  test " $i" = " --" && HELP=
+done
+test -n "$HELP" && {
+  echo "Syntax: $0 [options] -- /foo/binary -opts"
+  echo Options:
+  $DYNAMORIO_HOME/bin$VER/drrun -c /usr/local/lib/dynamorio/libcfg.so -h -- /bin/sh
+  exit 1
+}
+echo "[drcfg] using DynamoRIO"
+$DYNAMORIO_HOME/bin$VER/drrun -c /usr/local/lib/dynamorio/libcfg.so $*
+echo "[drcfg] done"