Christopher Haster / funcptr

Flexible templated function class and related utilities that avoid dynamic memory allocation without limiting functionality

Dependents:   SimpleHTTPExample

FuncPtr provides a flexible templated function class and related utilities while avoiding dynamic memory allocation and avoiding limited functionality.

FuncPtr provides an intuitive template interface:

FuncPtr<void(const char *)> func(puts);
func("hello!\n"); // prints hello!


Several function types are supported by FuncPtr:

// Simple C functions
void func();
FuncPtr<void()> fp(func);

// C++ Methods
struct Thing { void func(); };
Thing thing;
FuncPtr<void()> fp(&thing, &Thing::func);

// C functions with context
void func(Thing *);
FuncPtr<void()> fp(&thing, func);

// Function objects
struct Thing { void operator()(); };
Thing thing;
FuncPtr<void()> fp(&thing);


There is no dynamic memory allocation, managing memory is placed entirely on the user. More advanced function manipulation can be accomplished with statically allocated classes:

// Function binding
Binder<void(const char *), const char *> bind(putc, "hi!");
bind(); // prints hi!

// Function composition
Composer<int(const char *), const char *(int)> comp(puts, itoa);
comp(10); // prints 10

// Function chaining
Chainer<void(const char *), 2> chain;
chain.attach(puts);
chain.attach(puts);
chain("hi!\n"); // prints hi! twice


FuncPtr allows easy support of a large range of function types in C++ APIs with very few lines of code:

class Thing {
public:
    // The following two methods are sufficient for supporting 
    // every supported function type
    void attach(FuncPtr<void()> func) {
        _func.attach(func);
    }

    template<typename T, typename M>
    void attach(T *obj, M method) {
        attach(FuncPtr<void()>(obj, method));
    }

private:
    FuncPtr<void()> _func;
}


Additionally, FuncPtrs have several utilities for easy integration with C APIs:

// C style callbacks
void register_callback(void (*callback)(void *), void *data);

register_callback(&FuncPtr<void()>::thunk, &func);

// C style functions without context
void register_callback(void (*callback)());

Thunker thunk(func);
register_callback(thunk);

// mbed style callbacks
void register_callback(T *obj, void (T::*M)());

register_callback(&func, &FuncPtr<void()>::call);

Diff: trampoline.h

Revision:
16:c88d591ae0b4
Parent:
12:a005f8ca5d36
Child:
17:079c5ad807fb
--- a/trampoline.h	Sun Apr 17 22:01:07 2016 -0500
+++ b/trampoline.h	Wed Apr 20 02:17:49 2016 -0500
@@ -86,6 +86,9 @@
 }
 
 #elif defined(__i386__)
+#include <sys/mman.h>
+#include <unistd.h>
+
 struct trampoline {
     volatile uint8_t code[24];
     volatile uint32_t context;
@@ -113,6 +116,15 @@
     trampoline->context = (uint32_t)context;
     trampoline->callback = (uint32_t)callback;
 
+    // Mark region as executable
+    uintptr_t pagesize = sysconf(_SC_PAGESIZE);
+    uintptr_t start = (uintptr_t)trampoline & ~(pagesize-1);
+    uintptr_t size  = ((uintptr_t)trampoline - start) + sizeof(trampoline_t);
+    int err = mprotect((void*)start, size, PROT_READ | PROT_WRITE | PROT_EXEC);
+    if (err) {
+        return 0;
+    }
+
     // Return entry point
     return (entry_t *)trampoline->code;
 }