GDT and c++

[xyjamepa]

Hi guys..
i'm trying to rewrite my os using c++ but when trying
to program the GDT i've got this error:

gdt.o:gdt.cpp:(.text+0xe6):undefined reference to '__Z9gdt_flushv'

this error happened after linking the gdt.o with the rest of the kernel
I think the problem is about using c++ and asm...
my gdt.cpp

Code: Select all

struct gdt_entry
{
    unsigned short limit_low;
    unsigned short base_low;
    unsigned char base_middle;
    unsigned char access;
    unsigned char granularity;
    unsigned char base_high;
} __attribute__((packed));

struct gdt_ptr
{
    unsigned short limit;
    unsigned int base;
} __attribute__((packed));

/* Our GDT, with 3 entries, and finally our special GDT pointer */
struct gdt_entry gdt[3];
struct gdt_ptr gp;

/* This is in start.asm. We use this to properly reload
*  the new segment registers */

extern void gdt_flush();

/* Setup a descriptor in the Global Descriptor Table */
void gdt_set_gate(int num, unsigned long base, unsigned long limit, unsigned char access, unsigned char gran)
{
    /* Setup the descriptor base address */
    gdt[num].base_low = (base & 0xFFFF);
    gdt[num].base_middle = (base >> 16) & 0xFF;
    gdt[num].base_high = (base >> 24) & 0xFF;

    /* Setup the descriptor limits */
    gdt[num].limit_low = (limit & 0xFFFF);
    gdt[num].granularity = ((limit >> 16) & 0x0F);

    /* Finally, set up the granularity and access flags */
    gdt[num].granularity |= (gran & 0xF0);
    gdt[num].access = access;
}

/* Should be called by main. This will setup the special GDT
*  pointer, set up the first 3 entries in our GDT, and then
*  finally call gdt_flush() in our assembler file in order
*  to tell the processor where the new GDT is and update the
*  new segment registers */
void gdt_install()
{
    /* Setup the GDT pointer and limit */
    gp.limit = (sizeof(struct gdt_entry) * 3) - 1;
    //gp.base = (dword)&gdt;

    /* Our NULL descriptor */
    gdt_set_gate(0, 0, 0, 0, 0);

    /* The second entry is our Code Segment. The base address
    *  is 0, the limit is 4GBytes, it uses 4KByte granularity,
    *  uses 32-bit opcodes, and is a Code Segment descriptor.
    *  Please check the table above in the tutorial in order
    *  to see exactly what each value means */
    gdt_set_gate(1, 0, 0xFFFFFFFF, 0x9A, 0xCF);

    /* The third entry is our Data Segment. It's EXACTLY the
    *  same as our code segment, but the descriptor type in
    *  this entry's access byte says it's a Data Segment */
    gdt_set_gate(2, 0, 0xFFFFFFFF, 0x92, 0xCF);

    /* Flush out the old GDT and install the new changes! */
    gdt_flush();
    //printf("Installing GDT...[Done]\n");
}

the function gdt_flush in assembly:

Code: Select all

global _gdt_flush
extern _gp
_gdt_flush:
    lgdt [_gp]
    mov ax, 0x10
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax
    mov ss, ax
    jmp 0x08:flush2
flush2:
    ret

i'm using DJGPP and nasm.
Thanx.

[Solar]

The thing that gives you this headache is called "name mangling". C++ allows you to use the same function name several times - in different namespaces, overloaded with different parameter lists - and because the linker doesn't know about C++, the compiler has to encode this additional information of namespace / parameter list in the linker symbol so the linker can work correctly.

Your "gdt_flush()", thus, gets mangled into "__Z9gdt_flushv", which the linker cannot resolve because your assembly only defines _gdt_flush, oblivious to C++ name mangling.

Do not despair. Simply declare the function as

Code: Select all

extern "C" void gdt_flush();

to tell the compiler that this function is defined elsewhere, using C linkage.

[xyjamepa]

thank you Solar very much it works fine now.