diff options
Diffstat (limited to 'xpcom/reflect/xptcall/md/test/stub_test.cpp')
| -rw-r--r-- | xpcom/reflect/xptcall/md/test/stub_test.cpp | 209 |
1 files changed, 209 insertions, 0 deletions
diff --git a/xpcom/reflect/xptcall/md/test/stub_test.cpp b/xpcom/reflect/xptcall/md/test/stub_test.cpp new file mode 100644 index 0000000000..c83eb93ccc --- /dev/null +++ b/xpcom/reflect/xptcall/md/test/stub_test.cpp @@ -0,0 +1,209 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include <stdio.h> + +typedef unsigned nsresult; +typedef unsigned uint32_t; +typedef unsigned nsXPCVariant; + +#if defined(WIN32) +# define NS_IMETHOD virtual nsresult __stdcall +# define NS_IMETHODIMP nsresult __stdcall +#else +# define NS_IMETHOD virtual nsresult +# define NS_IMETHODIMP nsresult +#endif + +class base { + public: + NS_IMETHOD ignored() = 0; +}; + +class foo : public base { + public: + NS_IMETHOD callme1(int i, int j) = 0; + NS_IMETHOD callme2(int i, int j) = 0; + NS_IMETHOD callme3(int i, int j) = 0; +}; + +class bar : public foo { + public: + NS_IMETHOD ignored() override; + NS_IMETHOD callme1(int i, int j) override; + NS_IMETHOD callme2(int i, int j) override; + NS_IMETHOD callme3(int i, int j) override; +}; + +class baz : public base { + public: + NS_IMETHOD ignored() override; + NS_IMETHOD callme1() override; + NS_IMETHOD callme2() override; + NS_IMETHOD callme3() override; + void setfoo(foo* f) { other = f; } + + foo* other; +}; +NS_IMETHODIMP baz::ignored() { return 0; } + +NS_IMETHODIMP bar::ignored() { return 0; } + +NS_IMETHODIMP bar::callme1(int i, int j) { + printf("called bar::callme1 with: %d %d\n", i, j); + return 15; +} + +NS_IMETHODIMP bar::callme2(int i, int j) { + printf("called bar::callme2 with: %d %d\n", i, j); + return 25; +} + +NS_IMETHODIMP bar::callme3(int i, int j) { + printf("called bar::callme3 with: %d %d\n", i, j); + return 35; +} + +void docall(foo* f, int i, int j) { f->callme1(i, j); } + +/***************************************************************************/ +#if defined(WIN32) + +static int __stdcall PrepareAndDispatch(baz* self, uint32_t methodIndex, + uint32_t* args, + uint32_t* stackBytesToPop) { + fprintf(stdout, "PrepareAndDispatch (%p, %d, %p)\n", (void*)self, methodIndex, + (void*)args); + foo* a = self->other; + int p1 = (int)*args; + int p2 = (int)*(args + 1); + int out = 0; + switch (methodIndex) { + case 1: + out = a->callme1(p1, p2); + break; + case 2: + out = a->callme2(p1, p2); + break; + case 3: + out = a->callme3(p1, p2); + break; + } + *stackBytesToPop = 2 * 4; + return out; +} + +# ifndef __GNUC__ +static __declspec(naked) void SharedStub(void) { + __asm { + push ebp // set up simple stack frame + mov ebp, esp // stack has: ebp/vtbl_index/retaddr/this/args + push ecx // make room for a ptr + lea eax, [ebp-4] // pointer to stackBytesToPop + push eax + lea ecx, [ebp+16] // pointer to args + push ecx + mov edx, [ebp+4] // vtbl_index + push edx + mov eax, [ebp+12] // this + push eax + call PrepareAndDispatch + mov edx, [ebp+8] // return address + mov ecx, [ebp-4] // stackBytesToPop + add ecx, 12 // for this, the index, and ret address + mov esp, ebp + pop ebp + add esp, ecx // fix up stack pointer + jmp edx // simulate __stdcall return + } +} + +// these macros get expanded (many times) in the file #included below +# define STUB_ENTRY(n) \ + __declspec(naked) nsresult __stdcall baz::callme##n() { \ + __asm push n __asm jmp SharedStub \ + } + +# else /* __GNUC__ */ + +# define STUB_ENTRY(n) \ + nsresult __stdcall baz::callme##n() { \ + uint32_t *args, stackBytesToPop; \ + int result = 0; \ + baz* obj; \ + __asm__ __volatile__( \ + "leal 0x0c(%%ebp), %0\n\t" /* args */ \ + "movl 0x08(%%ebp), %1\n\t" /* this */ \ + : "=r"(args), "=r"(obj)); \ + result = PrepareAndDispatch(obj, n, args, &stackBytesToPop); \ + fprintf(stdout, "stub returning: %d\n", result); \ + fprintf(stdout, "bytes to pop: %d\n", stackBytesToPop); \ + return result; \ + } + +# endif /* ! __GNUC__ */ + +#else +/***************************************************************************/ +// just Linux_x86 now. Add other later... + +static int PrepareAndDispatch(baz* self, uint32_t methodIndex, uint32_t* args) { + foo* a = self->other; + int p1 = (int)*args; + int p2 = (int)*(args + 1); + switch (methodIndex) { + case 1: + a->callme1(p1, p2); + break; + case 2: + a->callme2(p1, p2); + break; + case 3: + a->callme3(p1, p2); + break; + } + return 1; +} + +# define STUB_ENTRY(n) \ + nsresult baz::callme##n() { \ + void* method = PrepareAndDispatch; \ + nsresult result; \ + __asm__ __volatile__( \ + "leal 0x0c(%%ebp), %%ecx\n\t" /* args */ \ + "pushl %%ecx\n\t" \ + "pushl $" #n \ + "\n\t" /* method index */ \ + "movl 0x08(%%ebp), %%ecx\n\t" /* this */ \ + "pushl %%ecx\n\t" \ + "call *%%edx" /* PrepareAndDispatch */ \ + : "=a"(result) /* %0 */ \ + : "d"(method) /* %1 */ \ + : "memory"); \ + return result; \ + } + +#endif +/***************************************************************************/ + +STUB_ENTRY(1) +STUB_ENTRY(2) +STUB_ENTRY(3) + +int main() { + foo* a = new bar(); + baz* b = new baz(); + + /* here we make the global 'check for alloc failure' checker happy */ + if (!a || !b) return 1; + + foo* c = (foo*)b; + + b->setfoo(a); + c->callme1(1, 2); + c->callme2(2, 4); + c->callme3(3, 6); + + return 0; +} |