How to remove this assembly code from C++ code?

Question

My environment is Visual Studio 2008.

I have 3 different libraries. In a summarized manner the behaviors of them are equivalent as follows.

Library 1 - Offers functions to be registered

class FunctionRegistry
{
   typedef std::list<int> TListInt;
   TListInt m_Params;
   void * m_FPtr;
public:
   FunctionRegistry(void * fptr):m_FPtr(fptr){}
   FunctionRegistry& Insert(int value){m_Params.push_back(value); return *this;}
   void Call();
};

void FunctionRegistry::Call()
{
    /*this is the area I want to get rid of */
    TListInt::iterator ite = m_Params.begin();
    while (ite != m_Params.end());
    {
       __asm push *ite;//I want to remvoe this assmebly code somehow
       ++ite;//Edited after initial post
    }

    ((void(*)())m_FPtr)();

    ite = m_Params.begin();
    while (ite != m_Params.end());
    {
        int i = 0;
        __asm pop i;//I want to remvoe this assmebly code somehow
        ++ite;//Edited after initial post
    }
    /*end of area to get rid of*/
}

Library 2 - Defines a set of functions like

void foo(int i, int j)
{
    std::cout << "foo int int " << i << " " << j << std::endl;
}

void bar(int i)
{
    std::cout << "bar int " << i << std::endl;
}

void biz()
{
    std::cout << "biz" << std::endl;
}

FunctionRegistry fRegFoo((void*)&foo);
fRegFoo.Insert(10).Insert(20);

FunctionRegistry fRegBar((void*)&bar);
fRegBar.Insert(10);

FunctionRegistry fRegBiz((void*)&biz);

Library 3 - This is the user of above two libraries and a sample usage would be like,

fRegFoo.Call();
fRegBar.Call();
fRegBiz.Call();

This is a legacy code and I'm trying now to get rid of above assembly code. I can easily change (with some API changes) my library 1 to cope with my need. But my problem is, due to massive distribution of the libraries among a large number of users, asking them to change their use cases (here library 3) according API changes of library 1 should be my last option.

Now, I am seeking your help, is there any way to change my library 1 internals with whatever possible techniques without changing its API to eliminate this assembly code?

If you think, it can't be achieved without any API change, please suggest ways having minimal code changes to library 3.

Answer 1

If your end users can only call the API as defined in your "Library 3" then the answer is obviously yes. The surface area of this API is tiny and it would be trivial to re-implement it without any assembly language. This would require changes in Lib 2 as well as Lib 1.

The naive implementation would be a set of classes with static Call functions. There are many other choices.

But the problem is: we haven't see all you have to show. If the API provided in Library 3 is rich, and/or if it is leaky, then the answer could be anywhere from 'easy-peasy' to 'give up and find another job'. Your call.

---

Note: this answer is based on what you said: that the API Lib 3 must not change, but everything else can. If instead you require a solution in which both Lib 2 and Lib 3 are unchanged and only the assembly code in Lib 1 can change, please edit your question to explain this.

If this is so, there are two choices: either standards compliant or relying on implementation-defined behaviour. [If it's Windows/VS only life may be easier, but I did this exact thing 20 years ago just so I could make it portable to lots of kinds of Unix too. It can definitely be done.]

Answer 2

This gets rid of the asm push & pop but you may end up with a big switch-statement, up to a max of 256 case-statements. (Possible to use a macro to generate the case-statements?)

void FunctionRegistry::Call()
{
    typedef void (*_F)(...);
    _F f = (_F)m_FPtr;

    auto p=*m_Params.begin();
    switch(m_Params.size())
    {
        case 0: f();break;
        case 1: f(p); break;
        case 2: f(p, p+1); break;
        //...
        //case 256: f( ...please get therapy... ); break
    }
}

Answer 3

Not 100% sure, but it looks like you're pushing the value ite points to to the stack and then poping it into i later. If that is all you are doing, consider replacing the asm push/pop with a std::stack. Something like:

#include <stack>
//...
void FunctionRegistry::Call()
{
    std::stack<TListInt::value_type> astack;
    TListInt::iterator ite = m_Params.begin();
    while (ite != m_Params.end());
    {
       astack.push(*ite);
       ++ite;//Edited after initial post
    }

    ((void(*)())m_FPtr)();

    ite = m_Params.begin();
    while (ite != m_Params.end());
    {
        int i = astack.pop();
        ++ite;//Edited after initial post
    }
}

Answer 4

Did you have a look at boost::bind ? Something like this :

#include <boost/bind/bind.hpp>
class FunctionRegistry
{
  typedef void tProcedure (void);

  private:
    const tProcedure proc;

  public:
    explicit FunctionRegistry( tProcedure proc ) : proc(proc) {}
    void Call() const { proc(); }

};

const FunctionRegistry fRegFoo( boost::bind( foo, 10, 20 ) );