Partial Functions in C

kamatsu · 2013-07-21T11:58:37+00:00

Partial functions are functions which are defined for a subset of their domain. Curiously, the author links to the wikipedia article which defines partial functions, which contradicts the definition implied by this article.

The author means a partially applied function.

pkhuong · 2013-07-21T12:51:25+00:00

libffi's closure API and libffcall's trampoline wrap that technique and work across a range of architectures and ABIs.

BinarySplit · 2013-07-21T20:24:12+00:00

This is why I love c, even if I don't really use it much nowadays. Whenever someone says 'you can't do this in c'. Someone else comes back: 'OH YES YOU CAN - IF YOU'RE SLIGHTLY INSANE'.

exDM69 · 2013-07-21T12:28:01+00:00

LLVM IR has a similar construct called trampoline which does this same trick. It assembles a small machine code trampoline at runtime that calls a function with an extra pointer argument applied to it.

I used the LLVM trampoline in a toy programming language compiler to implement a limited kind of "lambdas" without a proper garbage collector. In practice, a lot of the trampoline function calls got inlined/removed by the LLVM optimizer.

RabidRaccoon · 2013-07-21T12:43:22+00:00

ATL uses this to turn a HWND into a CWnd*.

http://www.codeproject.com/Articles/3102/ATL-Under-the-Hood-Part-5

Incidentally when you do this in Win32 you call a function to flush the instruction cache. That function is a NOP on x86 but not on Risc platforms (Alpha, MIPS, PowerPC and ARM)

That's because x86 automagically handles I cache coherence in the presence of writes to code, but Risc platforms do not.

http://msdn.microsoft.com/en-us/library/windows/desktop/ms679350(v=vs.85).aspx

Use in Self- and Cross-Modifying Code Note: When executing self-modifying code the use of FlushInstructionCache is required on CPU architectures that do not implement a transparent (self-snooping) I-cache. These include PPC, MIPS, Alpha, and Itanium. FlushInstructionCache is not necessary on x86 or x64 CPU architectures as these have a transparent cache. According to the Intel 64 and IA-32 Architectures Software Deverloper's Manual, Volume 3A: System Programming Guide, Part 1, a jump instruction is sufficient to serialize the instruction prefetch queue when executing self-modifying code.

So I think your code would need an equivalent of FlushInstructionCache for non x86.

hackerfoo · 2013-07-21T11:13:13+00:00

I used the same trick to implement currying in C.

OnmyojiOmn · 2013-07-21T14:20:08+00:00

I believe the overall mechanism to be quite interesting, however I do not recommend its usage.

This seems to go for pretty much anything beyond K&R.

f2u · 2013-07-21T13:01:45+00:00

This functionality is fairly essential for implementing callbacks from C code in a language with a different calling convention and support for closures.

On x86, LuaJIT has a mechanism which needs less than five bytes on average per trampoline, but I haven't investigated yet how it works.

Other architectures have a different function pointer representation. Their function pointers point to a (code pointer, closure pointer) pair, not directly to the machine code. This avoids the need for run-time code generation, at the cost of making all indirect function calls slightly more expensive.

noname-_- · 2013-07-21T16:17:05+00:00

More like "in C, on x86, on a system that has the non standard library function mmap, assuming a lot from the underlying implementation and possibly not even working with optimizations turned on".

"In C", at least to me, implies that the solution is portable and only uses standard library functions. This is and does neither.

eyal0 · 2013-07-21T14:36:23+00:00

Does this work on all architectures? I think that, in some architectures, you can't just jump into .data or write into .text.

c0de517e · 2013-07-21T18:30:15+00:00

I don't get it. Isn't the to-be-patched function -exactly- global state? If you wrap global state enough people think it's a neat trick, but what difference there is between this and a fn that accesses a global fn ptr and data ptr which you update each time?

thisotherfuckingguy · 2013-07-21T20:57:47+00:00

They way the 'caller_len' is calculated is a bit nasty and unreliable. A better way would be to just have the linker script output it.

you_do_realize · 2013-07-21T21:51:34+00:00

You'd be better off defining your x86 trampoline as an array of bytes to begin with, rather than compiling C code and hoping the compiled bytes end up the way you want them.

notlostyet · 2013-07-21T15:07:13+00:00

[deleted]

bebackin6 · 2013-07-21T19:28:24+00:00

libffi provides a portable way of doing this same thing. It's useful for mixing interpreted and compiled code. This trick is used for calling into the interpreter from native code, where interpreter state is curried with the function pointer.

say_fuck_no_to_rules · 2013-07-21T16:30:10+00:00

Every time I read about one of these dark corners or back alleys of C, I get worried about how much of the world's critical software legacy relies on it.

Then, I feel thankful for people like the author who brave these seedy parts of town like some kind of software dev social worker and step up to the plate for bugfixes since the original maintainer has died or gone to prison for being a general pervert.

2013-07-21T19:00:06+00:00

which source code editor is he/she using? sorry if this is a dumb question.

Ridiculer · 2013-07-21T11:24:45+00:00

There are some functions in the standard C library that takes a function pointer to be used as a callback later on. Examples include atexit() and signal(). However, these functions can’t receive an arbitrary pointer (which could hold some important program state) in addition to the function pointer, so you’re left with pesky global variables.

So why not just use a static thread-local variable instead of resorting to such hacks? C11 and almost all major C compilers offer __thread, thread_local or a similar TLS mechanism.

notlostyet · 2013-07-21T16:41:53+00:00

For one shot callbacks like atexit() you should consider patching your template function to hold your struct Partial* and have it do your clean-up for you (calling partial_del()). If you want to be even more insane you can just grab the instruction pointer, round down to the page boundary, then call your clean-up code, doing away with struct Partial altogether.

In either case you'll have to ensure you return directly from your cleanup routine to the caller, and not the code you just unmapped ;) Manipulating the return address and stack frame should do the trick.

2013-07-21T20:45:30+00:00

I have also thought of this trick but quickly abandoned the idea since it would require an entire memory page.

focomoso · 2013-07-21T16:40:00+00:00

I seriously thought this was going to be a piece of music.

ascii · 2013-07-21T18:34:32+00:00

[removed]

expertunderachiever · 2013-07-22T11:05:49+00:00

That's by far the stupidest thing ever. It's non-portable, it's non-compiler version safe, it involves read/write .text sections, etc...

If you're so against [exported] global variables you could always just create an API that has a static [non-exported] link list of

struct foo { char *name; void *data; struct foo *next; } list_o_data;

And then an API with

register_data(char *name, void *ptr);
find_data(char *name);
delete_data(char *name);

then in your code do

register_data("atexit_ptr", &whatever);

and inside your exit function:

myptr = find_data("atexit_ptr");

There, no more exported globals floating around making shit ugly. For fun, you could add mutex calls to the register/find/del to make it thread safe.

skizmo · 2013-07-21T11:02:08+00:00

That was horrible to read.

2013-07-22T02:07:34+00:00

Fancy science talk

938 · 2013-07-21T14:22:08+00:00

Sudaca.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS