Add x64 Windows implementation of SbiDllMgr

Work in progress. The passing of struct parameters is for sure
incorrect, for instance: A temporary copy needs to be allocated and
its address passed.

No assembly involved. The idea is to call the external function as if
it was a varargs one, and passing the four first qword-size parameters
as if they were doubles, thus nicely causing them to be both in the
integer and floating-point parameter registers, from either of which
the callee will get them, depending on their actual expected type.

Rename existing files a bit for clarity.

5 files changed, 852 insertions, 25 deletions

diff --git a/basic/source/runtime/dllmgr-none.cxx b/basic/source/runtime/dllmgr-none.cxx
new file mode 100644
index 000000000000..db32b646b619
--- /dev/null
+++ b/basic/source/runtime/dllmgr-none.cxx
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#include "precompiled_basic.hxx"
+#include "sal/config.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <list>
+#include <map>
+#include <vector>
+
+#include "basic/sbx.hxx"
+#include "basic/sbxvar.hxx"
+#include "osl/thread.h"
+#include "rtl/ref.hxx"
+#include "rtl/string.hxx"
+#include "rtl/ustring.hxx"
+#include "salhelper/simplereferenceobject.hxx"
+#include "tools/svwin.h"
+
+#include "dllmgr.hxx"
+
+struct SbiDllMgr::Impl {};
+
+SbError SbiDllMgr::Call(
+    rtl::OUString const &, rtl::OUString const &, SbxArray *, SbxVariable &,
+    bool)
+{
+    return ERRCODE_BASIC_NOT_IMPLEMENTED;
+}
+
+void SbiDllMgr::FreeDll(rtl::OUString const &) {}
+
+SbiDllMgr::SbiDllMgr(): impl_(new Impl) {}
+
+SbiDllMgr::~SbiDllMgr() {}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basic/source/runtime/dllmgr-x64.cxx b/basic/source/runtime/dllmgr-x64.cxx
new file mode 100644
index 000000000000..aa3ce5ea3e02
--- /dev/null
+++ b/basic/source/runtime/dllmgr-x64.cxx
@@ -0,0 +1,772 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#include "precompiled_basic.hxx"
+#include "sal/config.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <list>
+#include <map>
+#include <vector>
+
+#include "basic/sbx.hxx"
+#include "basic/sbxvar.hxx"
+#include "osl/thread.h"
+#include "rtl/ref.hxx"
+#include "rtl/string.hxx"
+#include "rtl/ustring.hxx"
+#include "salhelper/simplereferenceobject.hxx"
+#include "tools/svwin.h"
+
+#undef max
+
+#include "dllmgr.hxx"
+
+/* Open issues:
+
+   Missing support for functions returning structs (see TODO in call()).
+
+   Missing support for additional data types (64 bit integers, Any, ...; would
+   trigger OSL_ASSERT(false) in various switches).
+
+   It is assumed that the variables passed into SbiDllMgr::Call to represent
+   the arguments and return value have types that exactly match the Declare
+   statement; it would be better if this code had access to the function
+   signature from the Declare statement, so that it could convert the passed
+   variables accordingly.
+*/
+
+namespace {
+
+char * address(std::vector< char > & blob) {
+    return blob.empty() ? 0 : &blob[0];
+}
+
+SbError convert(rtl::OUString const & source, rtl::OString * target) {
+    return
+        source.convertToString(
+            target, osl_getThreadTextEncoding(),
+            (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
+             RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR))
+        ? ERRCODE_NONE : ERRCODE_BASIC_BAD_ARGUMENT;
+        //TODO: more specific errcode?
+}
+
+SbError convert(char const * source, sal_Int32 length, rtl::OUString * target) {
+    return
+        rtl_convertStringToUString(
+            &target->pData, source, length, osl_getThreadTextEncoding(),
+            (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
+             RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
+             RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))
+        ? ERRCODE_NONE : ERRCODE_BASIC_BAD_ARGUMENT;
+        //TODO: more specific errcode?
+}
+
+struct UnmarshalData {
+    UnmarshalData(SbxVariable * theVariable, void * theBuffer):
+        variable(theVariable), buffer(theBuffer) {}
+
+    SbxVariable * variable;
+    void * buffer;
+};
+
+struct StringData: public UnmarshalData {
+    StringData(SbxVariable * theVariable, void * theBuffer, bool theSpecial):
+        UnmarshalData(theVariable, theBuffer), special(theSpecial) {}
+
+    bool special;
+};
+
+class MarshalData: private boost::noncopyable {
+public:
+    std::vector< char > * newBlob() {
+        blobs_.push_front(std::vector< char >());
+        return &blobs_.front();
+    }
+
+    std::vector< UnmarshalData > unmarshal;
+
+    std::vector< StringData > unmarshalStrings;
+
+private:
+    std::list< std::vector< char > > blobs_;
+};
+
+std::size_t align(std::size_t address, std::size_t alignment) {
+    // alignment = 2^k for some k >= 0
+    return (address + (alignment - 1)) & ~(alignment - 1);
+}
+
+char * align(
+    std::vector< char > & blob, std::size_t alignment, std::size_t offset,
+    std::size_t add)
+{
+    std::vector< char >::size_type n = blob.size();
+    n = align(n - offset, alignment) + offset; //TODO: overflow in align()
+    blob.resize(n + add); //TODO: overflow
+    return address(blob) + n;
+}
+
+template< typename T > void add(
+    std::vector< char > & blob, T const & data, std::size_t alignment,
+    std::size_t offset)
+{
+    *reinterpret_cast< T * >(align(blob, alignment, offset, sizeof (T))) = data;
+}
+
+std::size_t alignment(SbxVariable * variable) {
+    OSL_ASSERT(variable != 0);
+    if ((variable->GetType() & SbxARRAY) == 0) {
+        switch (variable->GetType()) {
+        case SbxINTEGER:
+            return 2;
+        case SbxLONG:
+        case SbxSINGLE:
+        case SbxSTRING:
+            return 4;
+        case SbxDOUBLE:
+            return 8;
+        case SbxOBJECT:
+            {
+                std::size_t n = 1;
+                SbxArray * props = PTR_CAST(SbxObject, variable->GetObject())->
+                    GetProperties();
+                for (USHORT i = 0; i < props->Count(); ++i) {
+                    n = std::max(n, alignment(props->Get(i)));
+                }
+                return n;
+            }
+        case SbxBOOL:
+        case SbxBYTE:
+            return 1;
+        default:
+            OSL_ASSERT(false);
+            return 1;
+        }
+    } else {
+        SbxDimArray * arr = PTR_CAST(SbxDimArray, variable->GetObject());
+        int dims = arr->GetDims();
+        std::vector< INT32 > low(dims);
+        for (int i = 0; i < dims; ++i) {
+            INT32 up;
+            arr->GetDim32(i + 1, low[i], up);
+        }
+        return alignment(arr->Get32(&low[0]));
+    }
+}
+
+SbError marshal(
+    bool outer, SbxVariable * variable, bool special,
+    std::vector< char > & blob, std::size_t offset, MarshalData & data);
+
+SbError marshalString(
+    SbxVariable * variable, bool special, MarshalData & data, void ** buffer)
+{
+    OSL_ASSERT(variable != 0 && buffer != 0);
+    rtl::OString str;
+    SbError e = convert(variable->GetString(), &str);
+    if (e != ERRCODE_NONE) {
+        return e;
+    }
+    std::vector< char > * blob = data.newBlob();
+    blob->insert(blob->begin(), str.getStr(), str.getStr() + str.getLength());
+    *buffer = address(*blob);
+    data.unmarshalStrings.push_back(StringData(variable, *buffer, special));
+    return ERRCODE_NONE;
+}
+
+SbError marshalStruct(
+    SbxVariable * variable, std::vector< char > & blob, std::size_t offset,
+    MarshalData & data)
+{
+    OSL_ASSERT(variable != 0);
+    SbxArray * props = PTR_CAST(SbxObject, variable->GetObject())->
+        GetProperties();
+    for (USHORT i = 0; i < props->Count(); ++i) {
+        SbError e = marshal(false, props->Get(i), false, blob, offset, data);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+    }
+    return ERRCODE_NONE;
+}
+
+SbError marshalArray(
+    SbxVariable * variable, std::vector< char > & blob, std::size_t offset,
+    MarshalData & data)
+{
+    OSL_ASSERT(variable != 0);
+    SbxDimArray * arr = PTR_CAST(SbxDimArray, variable->GetObject());
+    int dims = arr->GetDims();
+    std::vector< INT32 > low(dims);
+    std::vector< INT32 > up(dims);
+    for (int i = 0; i < dims; ++i) {
+        arr->GetDim32(i + 1, low[i], up[i]);
+    }
+    for (std::vector< INT32 > idx = low;;) {
+        SbError e = marshal(
+            false, arr->Get32(&idx[0]), false, blob, offset, data);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+        int i = dims - 1;
+        while (idx[i] == up[i]) {
+            idx[i] = low[i];
+            if (i == 0) {
+                return ERRCODE_NONE;
+            }
+            --i;
+        }
+        ++idx[i];
+    }
+}
+
+// 8-aligned structs are only 4-aligned on stack, so alignment of members in
+// such structs must take that into account via "offset"
+SbError marshal(
+    bool outer, SbxVariable * variable, bool special,
+    std::vector< char > & blob, std::size_t offset, MarshalData & data)
+{
+    OSL_ASSERT(variable != 0);
+    if ((variable->GetFlags() & SBX_REFERENCE) == 0) {
+        if ((variable->GetType() & SbxARRAY) == 0) {
+            switch (variable->GetType()) {
+            case SbxINTEGER:
+                add(blob, variable->GetInteger(), outer ? 8 : 2, offset);
+                break;
+            case SbxLONG:
+                add(blob, variable->GetLong(), outer ? 8 : 4, offset);
+                break;
+            case SbxSINGLE:
+                add(blob, variable->GetSingle(), outer ? 8 : 4, offset);
+                break;
+            case SbxDOUBLE:
+                add(blob, variable->GetDouble(), 8, offset);
+                break;
+            case SbxSTRING:
+                {
+                    void * p;
+                    SbError e = marshalString(variable, special, data, &p);
+                    if (e != ERRCODE_NONE) {
+                        return e;
+                    }
+                    add(blob, p, 8, offset);
+                    break;
+                }
+            case SbxOBJECT:
+                {
+                    align(blob, outer ? 8 : alignment(variable), offset, 0);
+                    SbError e = marshalStruct(variable, blob, offset, data);
+                    if (e != ERRCODE_NONE) {
+                        return e;
+                    }
+                    break;
+                }
+            case SbxBOOL:
+                add(blob, variable->GetBool(), outer ? 8 : 1, offset);
+                break;
+            case SbxBYTE:
+                add(blob, variable->GetByte(), outer ? 8 : 1, offset);
+                break;
+            default:
+                OSL_ASSERT(false);
+                break;
+            }
+        } else {
+            SbError e = marshalArray(variable, blob, offset, data);
+            if (e != ERRCODE_NONE) {
+                return e;
+            }
+        }
+    } else {
+        if ((variable->GetType() & SbxARRAY) == 0) {
+            switch (variable->GetType()) {
+            case SbxINTEGER:
+            case SbxLONG:
+            case SbxSINGLE:
+            case SbxDOUBLE:
+            case SbxBOOL:
+            case SbxBYTE:
+                add(blob, variable->data(), 8, offset);
+                break;
+            case SbxSTRING:
+                {
+                    std::vector< char > * blob2 = data.newBlob();
+                    void * p;
+                    SbError e = marshalString(variable, special, data, &p);
+                    if (e != ERRCODE_NONE) {
+                        return e;
+                    }
+                    add(*blob2, p, 8, 0);
+                    add(blob, address(*blob2), 8, offset);
+                    break;
+                }
+            case SbxOBJECT:
+                {
+                    std::vector< char > * blob2 = data.newBlob();
+                    SbError e = marshalStruct(variable, *blob2, 0, data);
+                    if (e != ERRCODE_NONE) {
+                        return e;
+                    }
+                    void * p = address(*blob2);
+                    if (outer) {
+                        data.unmarshal.push_back(UnmarshalData(variable, p));
+                    }
+                    add(blob, p, 8, offset);
+                    break;
+                }
+            default:
+                OSL_ASSERT(false);
+                break;
+            }
+        } else {
+            std::vector< char > * blob2 = data.newBlob();
+            SbError e = marshalArray(variable, *blob2, 0, data);
+            if (e != ERRCODE_NONE) {
+                return e;
+            }
+            void * p = address(*blob2);
+            if (outer) {
+                data.unmarshal.push_back(UnmarshalData(variable, p));
+            }
+            add(blob, p, 8, offset);
+        }
+    }
+    return ERRCODE_NONE;
+}
+
+template< typename T > T read(void const ** pointer) {
+    T const * p = static_cast< T const * >(*pointer);
+    *pointer = static_cast< void const * >(p + 1);
+    return *p;
+}
+
+void const * unmarshal(SbxVariable * variable, void const * data) {
+    OSL_ASSERT(variable != 0);
+    if ((variable->GetType() & SbxARRAY) == 0) {
+        switch (variable->GetType()) {
+        case SbxINTEGER:
+            variable->PutInteger(read< sal_Int16 >(&data));
+            break;
+        case SbxLONG:
+            variable->PutLong(read< sal_Int32 >(&data));
+            break;
+        case SbxSINGLE:
+            variable->PutSingle(read< float >(&data));
+            break;
+        case SbxDOUBLE:
+            variable->PutDouble(read< double >(&data));
+            break;
+        case SbxSTRING:
+            read< char * >(&data); // handled by unmarshalString
+            break;
+        case SbxOBJECT:
+            {
+                data = reinterpret_cast< void const * >(
+                    align(
+                        reinterpret_cast< sal_uIntPtr >(data),
+                        alignment(variable)));
+                SbxArray * props = PTR_CAST(SbxObject, variable->GetObject())->
+                    GetProperties();
+                for (USHORT i = 0; i < props->Count(); ++i) {
+                    data = unmarshal(props->Get(i), data);
+                }
+                break;
+            }
+        case SbxBOOL:
+            variable->PutBool(read< sal_Bool >(&data));
+            break;
+        case SbxBYTE:
+            variable->PutByte(read< sal_uInt8 >(&data));
+            break;
+        default:
+            OSL_ASSERT(false);
+            break;
+        }
+    } else {
+        SbxDimArray * arr = PTR_CAST(SbxDimArray, variable->GetObject());
+        int dims = arr->GetDims();
+        std::vector< INT32 > low(dims);
+        std::vector< INT32 > up(dims);
+        for (int i = 0; i < dims; ++i) {
+            arr->GetDim32(i + 1, low[i], up[i]);
+        }
+        for (std::vector< INT32 > idx = low;;) {
+            data = unmarshal(arr->Get32(&idx[0]), data);
+            int i = dims - 1;
+            while (idx[i] == up[i]) {
+                idx[i] = low[i];
+                if (i == 0) {
+                    goto done;
+                }
+                --i;
+            }
+            ++idx[i];
+        }
+    done:;
+    }
+    return data;
+}
+
+SbError unmarshalString(StringData const & data, SbxVariable & result) {
+    rtl::OUString str;
+    if (data.buffer != 0) {
+        char const * p = static_cast< char const * >(data.buffer);
+        sal_Int32 len;
+        if (data.special) {
+            len = static_cast< sal_Int32 >(result.GetULong());
+            if (len < 0) { // i.e., DWORD result >= 2^31
+                return ERRCODE_BASIC_BAD_ARGUMENT;
+                    //TODO: more specific errcode?
+            }
+        } else {
+            len = rtl_str_getLength(p);
+        }
+        SbError e = convert(p, len, &str);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+    }
+    data.variable->PutString(String(str));
+    return ERRCODE_NONE;
+}
+
+struct ProcData {
+    rtl::OString name;
+    FARPROC proc;
+};
+
+SbError call(
+    rtl::OUString const & dll, ProcData const & proc, SbxArray * arguments,
+    SbxVariable & result)
+{
+    if (arguments->Count() > 20)
+        return ERRCODE_BASIC_NOT_IMPLEMENTED;
+
+    std::vector< char > stack;
+    MarshalData data;
+
+    // For DWORD GetLogicalDriveStringsA(DWORD nBufferLength, LPSTR lpBuffer)
+    // from kernel32, upon return, filled lpBuffer length is result DWORD, which
+    // requires special handling in unmarshalString; other functions might
+    // require similar treatment, too:
+    bool special =
+        dll.equalsIgnoreAsciiCaseAsciiL(
+            RTL_CONSTASCII_STRINGPARAM("KERNEL32.DLL")) &&
+        (proc.name ==
+         rtl::OString(RTL_CONSTASCII_STRINGPARAM("GetLogicalDriveStringsA")));
+    for (int i = 1; i < (arguments == 0 ? 0 : arguments->Count()); ++i) {
+        SbError e = marshal(
+            true, arguments->Get(i), special && i == 2, stack, stack.size(),
+            data);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+        align(stack, 8, 0, 0);
+    }
+
+    stack.resize(20*8);
+
+    // We fake all calls as being to a varargs function,
+    // as this means any floating-point argument among the first four
+    // ones will end up in a XMM register where the callee expects it.
+    sal_Int32 (*proc_i)(double d, ...) = (sal_Int32 (*)(double, ...)) proc.proc;
+    double (*proc_d)(double d, ...) = (double (*)(double, ...)) proc.proc;
+
+    sal_Int64 iRetVal;
+    double dRetVal;
+
+    switch (result.GetType()) {
+    case SbxEMPTY:
+    case SbxINTEGER:
+    case SbxLONG:
+    case SbxSTRING:
+    case SbxOBJECT:
+    case SbxBOOL:
+    case SbxBYTE:
+        iRetVal =
+            proc_i(*(double *)&stack[0*8],
+                   *(double *)&stack[1*8],
+                   *(double *)&stack[2*8],
+                   *(double *)&stack[3*8],
+                   *(sal_uInt64 *)&stack[4*8],
+                   *(sal_uInt64 *)&stack[5*8],
+                   *(sal_uInt64 *)&stack[6*8],
+                   *(sal_uInt64 *)&stack[7*8],
+                   *(sal_uInt64 *)&stack[8*8],
+                   *(sal_uInt64 *)&stack[9*8],
+                   *(sal_uInt64 *)&stack[10*8],
+                   *(sal_uInt64 *)&stack[11*8],
+                   *(sal_uInt64 *)&stack[12*8],
+                   *(sal_uInt64 *)&stack[13*8],
+                   *(sal_uInt64 *)&stack[14*8],
+                   *(sal_uInt64 *)&stack[15*8],
+                   *(sal_uInt64 *)&stack[16*8],
+                   *(sal_uInt64 *)&stack[17*8],
+                   *(sal_uInt64 *)&stack[18*8],
+                   *(sal_uInt64 *)&stack[19*8]);
+        break;
+    case SbxSINGLE:
+    case SbxDOUBLE:
+        dRetVal =
+            proc_d(*(double *)&stack[0*8],
+                   *(double *)&stack[1*8],
+                   *(double *)&stack[2*8],
+                   *(double *)&stack[3*8],
+                   *(sal_uInt64 *)&stack[4*8],
+                   *(sal_uInt64 *)&stack[5*8],
+                   *(sal_uInt64 *)&stack[6*8],
+                   *(sal_uInt64 *)&stack[7*8],
+                   *(sal_uInt64 *)&stack[8*8],
+                   *(sal_uInt64 *)&stack[9*8],
+                   *(sal_uInt64 *)&stack[10*8],
+                   *(sal_uInt64 *)&stack[11*8],
+                   *(sal_uInt64 *)&stack[12*8],
+                   *(sal_uInt64 *)&stack[13*8],
+                   *(sal_uInt64 *)&stack[14*8],
+                   *(sal_uInt64 *)&stack[15*8],
+                   *(sal_uInt64 *)&stack[16*8],
+                   *(sal_uInt64 *)&stack[17*8],
+                   *(sal_uInt64 *)&stack[18*8],
+                   *(sal_uInt64 *)&stack[19*8]);
+    }
+
+    switch (result.GetType()) {
+    case SbxEMPTY:
+        break;
+    case SbxINTEGER:
+        result.PutInteger(static_cast< sal_Int16 >(iRetVal));
+        break;
+    case SbxLONG:
+        result.PutLong(static_cast< sal_Int32 >(iRetVal));
+        break;
+    case SbxSINGLE:
+        result.PutSingle(static_cast< float >(dRetVal));
+        break;
+    case SbxDOUBLE:
+        result.PutDouble(dRetVal);
+        break;
+    case SbxSTRING:
+        {
+            char const * s1 = reinterpret_cast< char const * >(iRetVal);
+            rtl::OUString s2;
+            SbError e = convert(s1, rtl_str_getLength(s1), &s2);
+            if (e != ERRCODE_NONE) {
+                return e;
+            }
+            result.PutString(String(s2));
+            break;
+        }
+    case SbxOBJECT:
+        //TODO
+        break;
+    case SbxBOOL:
+        result.PutBool(static_cast< sal_Bool >(iRetVal));
+        break;
+    case SbxBYTE:
+        result.PutByte(static_cast< sal_uInt8 >(iRetVal));
+        break;
+    default:
+        OSL_ASSERT(false);
+        break;
+    }
+    for (int i = 1; i < (arguments == 0 ? 0 : arguments->Count()); ++i) {
+        arguments->Get(i)->ResetFlag(SBX_REFERENCE);
+            //TODO: skipped for errors?!?
+    }
+    for (std::vector< UnmarshalData >::iterator i(data.unmarshal.begin());
+         i != data.unmarshal.end(); ++i)
+    {
+        unmarshal(i->variable, i->buffer);
+    }
+    for (std::vector< StringData >::iterator i(data.unmarshalStrings.begin());
+         i != data.unmarshalStrings.end(); ++i)
+    {
+        SbError e = unmarshalString(*i, result);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+    }
+    return ERRCODE_NONE;
+}
+
+SbError getProcData(HMODULE handle, rtl::OUString const & name, ProcData * proc)
+{
+    OSL_ASSERT(proc != 0);
+    if (name.getLength() != 0 && name[0] == '@') { //TODO: "@" vs. "#"???
+        sal_Int32 n = name.copy(1).toInt32(); //TODO: handle bad input
+        if (n <= 0 || n > 0xFFFF) {
+            return ERRCODE_BASIC_BAD_ARGUMENT; //TODO: more specific errcode?
+        }
+        FARPROC p = GetProcAddress(handle, reinterpret_cast< LPCSTR >(n));
+        if (p != 0) {
+            proc->name = rtl::OString(RTL_CONSTASCII_STRINGPARAM("#")) +
+                rtl::OString::valueOf(n);
+            proc->proc = p;
+            return ERRCODE_NONE;
+        }
+    } else {
+        rtl::OString name8;
+        SbError e = convert(name, &name8);
+        if (e != ERRCODE_NONE) {
+            return e;
+        }
+        FARPROC p = GetProcAddress(handle, name8.getStr());
+        if (p != 0) {
+            proc->name = name8;
+            proc->proc = p;
+            return ERRCODE_NONE;
+        }
+        sal_Int32 i = name8.indexOf('#');
+        if (i != -1) {
+            name8 = name8.copy(0, i);
+            p = GetProcAddress(handle, name8.getStr());
+            if (p != 0) {
+                proc->name = name8;
+                proc->proc = p;
+                return ERRCODE_NONE;
+            }
+        }
+        rtl::OString real(
+            rtl::OString(RTL_CONSTASCII_STRINGPARAM("_")) + name8);
+        p = GetProcAddress(handle, real.getStr());
+        if (p != 0) {
+            proc->name = real;
+            proc->proc = p;
+            return ERRCODE_NONE;
+        }
+        real = name8 + rtl::OString(RTL_CONSTASCII_STRINGPARAM("A"));
+        p = GetProcAddress(handle, real.getStr());
+        if (p != 0) {
+            proc->name = real;
+            proc->proc = p;
+            return ERRCODE_NONE;
+        }
+    }
+    return ERRCODE_BASIC_PROC_UNDEFINED;
+}
+
+struct Dll: public salhelper::SimpleReferenceObject {
+private:
+    typedef std::map< rtl::OUString, ProcData > Procs;
+
+    virtual ~Dll();
+
+public:
+    Dll(): handle(0) {}
+
+    SbError getProc(rtl::OUString const & name, ProcData * proc);
+
+    HMODULE handle;
+    Procs procs;
+};
+
+Dll::~Dll() {
+    if (handle != 0 && !FreeLibrary(handle)) {
+        OSL_TRACE("FreeLibrary(%p) failed with %u", handle, GetLastError());
+    }
+}
+
+SbError Dll::getProc(rtl::OUString const & name, ProcData * proc) {
+    Procs::iterator i(procs.find(name));
+    if (i != procs.end()) {
+        *proc = i->second;
+        return ERRCODE_NONE;
+    }
+    SbError e = getProcData(handle, name, proc);
+    if (e == ERRCODE_NONE) {
+        procs.insert(Procs::value_type(name, *proc));
+    }
+    return e;
+}
+
+rtl::OUString fullDllName(rtl::OUString const & name) {
+    rtl::OUString full(name);
+    if (full.indexOf('.') == -1) {
+        full += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(".DLL"));
+    }
+    return full;
+}
+
+}
+
+struct SbiDllMgr::Impl: private boost::noncopyable {
+private:
+    typedef std::map< rtl::OUString, rtl::Reference< Dll > > Dlls;
+
+public:
+    Dll * getDll(rtl::OUString const & name);
+
+    Dlls dlls;
+};
+
+Dll * SbiDllMgr::Impl::getDll(rtl::OUString const & name) {
+    Dlls::iterator i(dlls.find(name));
+    if (i == dlls.end()) {
+        i = dlls.insert(Dlls::value_type(name, new Dll)).first;
+        HMODULE h = LoadLibraryW(reinterpret_cast<LPCWSTR>(name.getStr()));
+        if (h == 0) {
+            dlls.erase(i);
+            return 0;
+        }
+        i->second->handle = h;
+    }
+    return i->second.get();
+}
+
+SbError SbiDllMgr::Call(
+    rtl::OUString const & function, rtl::OUString const & library,
+    SbxArray * arguments, SbxVariable & result, bool cdeclConvention)
+{
+    if (cdeclConvention) {
+        return ERRCODE_BASIC_NOT_IMPLEMENTED;
+    }
+    rtl::OUString dllName(fullDllName(library));
+    Dll * dll = impl_->getDll(dllName);
+    if (dll == 0) {
+        return ERRCODE_BASIC_BAD_DLL_LOAD;
+    }
+    ProcData proc;
+    SbError e = dll->getProc(function, &proc);
+    if (e != ERRCODE_NONE) {
+        return e;
+    }
+    return call(dllName, proc, arguments, result);
+}
+
+void SbiDllMgr::FreeDll(rtl::OUString const & library) {
+    impl_->dlls.erase(library);
+}
+
+SbiDllMgr::SbiDllMgr(): impl_(new Impl) {}
+
+SbiDllMgr::~SbiDllMgr() {}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/basic/source/runtime/dllmgr.cxx b/basic/source/runtime/dllmgr-x86.cxx
index 2afaa356640f..09aee07fc934 100644
--- a/basic/source/runtime/dllmgr.cxx
+++ b/basic/source/runtime/dllmgr-x86.cxx
@@ -50,8 +50,6 @@
 
 /* Open issues:
 
-   Only 32-bit Windows for now.
-
    Missing support for functions returning structs (see TODO in call()).
 
    Missing support for additional data types (64 bit integers, Any, ...; would
@@ -64,8 +62,6 @@
    variables accordingly.
 */
 
-#if defined WNT // only 32-bit Windows, actually
-
 extern "C" {
 
 int __stdcall DllMgr_call32(FARPROC, void const * stack, std::size_t size);
@@ -719,21 +715,6 @@ void SbiDllMgr::FreeDll(rtl::OUString const & library) {
     impl_->dlls.erase(library);
 }
 
-#else
-
-struct SbiDllMgr::Impl {};
-
-SbError SbiDllMgr::Call(
-    rtl::OUString const &, rtl::OUString const &, SbxArray *, SbxVariable &,
-    bool)
-{
-    return ERRCODE_BASIC_NOT_IMPLEMENTED;
-}
-
-void SbiDllMgr::FreeDll(rtl::OUString const &) {}
-
-#endif
-
 SbiDllMgr::SbiDllMgr(): impl_(new Impl) {}
 
 SbiDllMgr::~SbiDllMgr() {}
diff --git a/basic/source/runtime/makefile.mk b/basic/source/runtime/makefile.mk
index f2ed11196b28..f8c81032a20e 100644
--- a/basic/source/runtime/makefile.mk
+++ b/basic/source/runtime/makefile.mk
@@ -41,7 +41,7 @@ ENABLE_EXCEPTIONS = TRUE
 
 SLOFILES=	\
     $(SLO)$/basrdll.obj	\
-    $(SLO)$/inputbox.obj	\
+    $(SLO)$/inputbox.obj\
     $(SLO)$/runtime.obj	\
     $(SLO)$/step0.obj	\
     $(SLO)$/step1.obj	\
@@ -50,15 +50,25 @@ SLOFILES=	\
     $(SLO)$/stdobj.obj	\
     $(SLO)$/stdobj1.obj	\
     $(SLO)$/methods.obj	\
-    $(SLO)$/methods1.obj	\
+    $(SLO)$/methods1.obj\
     $(SLO)$/props.obj	\
-    $(SLO)$/ddectrl.obj	\
-    $(SLO)$/dllmgr.obj
+    $(SLO)$/ddectrl.obj
 
+.IF "$(GUI)$(CPU)" == "WNTI"
+SLOFILES+= \
+    $(SLO)$/dllmgr-x86.obj
+.ELIF "$(GUI)$(CPU)" == "WNTX"
+SLOFILES+= \
+    $(SLO)$/dllmgr-x64.obj
+.ELSE
+SLOFILES+= \
+    $(SLO)$/dllmgr-none.obj
+.ENDIF
 .IF "$(GUI)$(COM)$(CPU)" == "WNTMSCI"
-SLOFILES+=	$(SLO)$/wnt.obj
+    $(SLO)$/wnt-x86.obj
 .ELIF "$(GUI)$(COM)$(CPU)" == "WNTGCCI"
-SLOFILES+=	$(SLO)$/wnt-mingw.obj
+SLOFILES+= \
+    $(SLO)$/wnt-mingw.obj
 .ENDIF
 
 # --- Targets -------------------------------------------------------------
diff --git a/basic/source/runtime/wnt.asm b/basic/source/runtime/wnt-x86.asm
index 2a8710e34243..2a8710e34243 100644
--- a/basic/source/runtime/wnt.asm
+++ b/basic/source/runtime/wnt-x86.asm