What is this error about?

Question

ALL,

I'm using Anjuta to do my development.

I created a project for my main application, and then made 2 more: 1 for the static library (libdbinterface.a) and 1 for the dynamic library (libsqlite_lib.so).

Both those libraries contains one exported class each: libdbinterface.a - class Database, libsqlite_lib.so - public SQLiteDatabase : public Database.

Now I'm trying to link libdbinterface.a to libsqlite_lib.so.

So in Anjuta I added following to the "Linker Option" for the target libsqlite_lib.so:

-L/home/igor/dbhandler/Debug/dbinterface -ldbinterface

However, trying to compile I received following error from linker:

/usr/lib/gcc/x86_64-pc-linux-gnu/4.8.4/../../../../x86_64-pc-linux-gnu/bin/ld: /home/igor/dbhandler/Debug/dbinterface/libdbinterface.a(database.o): relocation R_X86_64_32S against `_ZTV8Database' can not be used when making a shared object; recompile with -fPIC

I tried to recompile libsqlite_lib.so with -fPIC explicitely added to "C++ Options" of that project but that didn't solve it - I still receive the same error.

Unfortunately trying to Google on how to link .a and .so is not helpful.

Can someone sched some light on how to fix this error?

TIA.

[EDIT] libsqlite_lib.so Makefile - https://bpaste.net/show/1495231e58cc libdbinterface.a Makefile - https://bpaste.net/show/3a71c119d0fc

libdbinterface.a contains 2 files databse.h:

#ifndef DBMANAGER_DATABASE
#define DBMANAGER_DATABASE

class Field
{
public:
    Field(const std::string &columnName, const std::string &columnType, const std::string &columnDefaultValue = "", const bool columnIsNull = false, const bool columnPK = false)
    {
        column_name = columnName;
        column_type = columnType;
        column_defaultValue = columnDefaultValue;
        column_isNull = columnIsNull;
        column_pk = columnPK;
    }
private:
    std::string column_name, column_type, column_defaultValue;
    bool column_isNull, column_pk;
};

struct FKField
{
    FKField(const std::string &table_name, const std::string &original_field, const std::string &referenced_field)
    {
        tableName = table_name;
        originalField = original_field;
        referencedField = referenced_field;
    }
    std::string tableName, originalField, referencedField;
};

class Table
{
public:
    Table(const std::string &tableName, const std::vector<Field> &tableFields, const std::map<int,std::vector<FKField> > &foreignKeys)
    {
        table_name = tableName;
        table_fields = tableFields;
        foreign_keys = foreignKeys;
    }
    const std::string &GetTableName() { return table_name; }
    std::map<int,std::vector<FKField> > &GetForeignKeyVector() { return foreign_keys; }
private:
    std::string table_name;
    std::vector<Field> table_fields;
    std::map<int,std::vector<FKField> > foreign_keys;
};

#ifdef WIN32
class __declspec(dllexport) Database
#else
class Database
#endif
{
private:
    struct Impl;
    Impl *pimpl;
public:
    Database();
    virtual ~Database();
    Impl &GetTableVector();
    static void *operator new(std::size_t size);
    static void operator delete(void *ptr, std::size_t size);
    virtual int Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg);
    virtual int GetTableListFromDb(std::string &) { return 0; }
};

#endif

and database.cpp:

#ifdef WIN32
#include <windows.h>
#endif
#include <map>
#include <vector>
#include <string>
#include <sqlext.h>
#include "database.h"

struct Database::Impl
{
    std::vector<Table> m_tables;
};

Database::Database() : pimpl( new Impl )
{
}

Database::~Database()
{
    delete pimpl;
}

void *Database::operator new(std::size_t size)
{
    return ::operator new( size );
}

void Database::operator delete(void *ptr, std::size_t size)
{
    return ::operator delete( ptr );
}

Database::Impl &Database::GetTableVector()
{
    return *pimpl;
}

int Database::Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg)
{
    selectedDSN = selectedDSN;
    errorMsg = errorMsg;
    return 0;
}

libsqlite_lib.so has also 2 files: database_sqlite.h

#ifndef DBMANAGER_SQLITE
#define DBMANAGER_SQLITE

#ifdef WIN32
class __declspec(dllexport) SQLiteDatabase : public Database
#else
class SQLiteDatabase : public Database
#endif
{
public:
    SQLiteDatabase();
    ~SQLiteDatabase();
    virtual int Connect(const char *selectedDSN, std::vector<std::wstring> &errorMsg);
    virtual int GetTableListFromDb(std::vector<std::wstring> &errorMsg);
protected:
    void GetErrorMessage(int code, std::wstring &errorMsg);
private:
    sqlite3 *m_db;
};

#endif

and database_sqlite.cpp with the actual implementation. [/EDIT]

Answer 1

Well, apparently the solution is to rebuild static library with "-fPIC", not the dynamic one.

Thank you for reading.