Data type and register location errors on compilation

[antoine]

Hi all! I'm a French student currently doing an internship in Beijing. I have to simulate a mips machine running with the micro kernel l4. When i compile the kernel i got some compilation errors. I solved most of them but here I'm stuck and I hope you could help me.
Here is the error message :

/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:233:2 : warning: #warning VU: do we have to preserve prios on ex-regs?
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:248:2 : warning: #warning eSk: Halting a thread with ongoing kernel operations is not supported
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc: In function `threadid_t sys_exchange_re gisters(threadi d_t, word_t, word_t, word_t, word_t, word_t, threadid_t, bool)':
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:333: error: data type of 'pgr' isn't suitable for a register
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:333: error: register name given for non-register variable 'pgr'
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:333: confused by earlier errors, bailing out
make[1]: *** [src/api/v4/exregs.o] Error 1

And here is the concerned code :

// Only allow exregs on:
    //  - active threads
    //  - in the same address space
    //  - with a valid thread ID.
    if ((! tcb->is_activated ()) || (! has_exregs_perms(tcb, dest_tid)) )
    {
    get_current_tcb ()->set_error_code (EINVALID_THREAD);
    return_exchange_registers (threadid_t::nilthread (), 0, 0, 0, 0,
                   threadid_t::nilthread (), 0);
    }
 

The 333 line is the one beginning with return_... and I've searched what is pgr all over the file but I've found nor variables neither functions with this name.
Hope you'll understand this better than me ;)
Thanks
Antoine

[weaknessforcats]

Is it in a library? It may not be in your source code.

[antoine]

In fact I've continued to search and i ve found this portion of code in an included file :

#define return_exchange_registers(result, control, sp, ip, flags, pager, handle)    \
{                                \
    register word_t ctrl asm("$4") = control;    /* a0 */    \
    register word_t sp_r asm("$5") = sp;    /* a1 */    \
    register word_t ip_r asm("$6") = ip;    /* a2 */    \
    register word_t flg asm("$7") = flags;    /* a3 */    \
    register threadid_t pgr asm("$8") = pager;    /* t0 */    \
    register word_t hdl asm("$9") = handle;    /* t1 */    \
\
    __asm__ __volatile__ (                    \
    "" : : "r" (ctrl), "r" (sp_r), "r" (ip_r),        \
    "r" (flg), "r" (pgr), "r" (hdl)                \
    );                                \
    return (result);                        \
}
 

With this it becomes a bit clearer. I think that we can't put a threadid_t into a register. But what can i do to solve that? Is register a predefined type in C++ or not?
I hope it would help you to help me ;)
Bye
Antoine

[weaknessforcats]

register is a strage class specifer. It suggests to the compiler that the variable should be kept in a register instead of existing as a variable in memory. The compiler is free to ignore this suggestion.

A register is most likely 32 or 64 bits depending on the chip. If your threadid_t fits you can use a register. This code:

register threadid_t pgr asm("$8") = pager; /* t0 */ \

says the threadid_t will fit in a register.

In this line, pgr is the name of the variable. threadid_t is the type. and register is the storage class specifer.

However, this error:

/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc: In function `threadid_t sys_exchange_re gisters(threadi d_t, word_t, word_t, word_t, word_t, word_t, threadid_t, bool)':
/home/antoine/Final/pistachio/kernel/src/api/v4/exregs.cc:333: error: data type of 'pgr' isn't suitable for a register

says that the data type of pgr (that's threadid_t) won't fit in a register.

What does thread_t look like? Is it a struct?? Or is it a typedef of some kind??

[antoine]

Hi thank you for your help. Here is how threadid_t is defined :

public:
042 static threadid_t anythread() {
043 threadid_t tid;
044 tid.raw = (word_t)-1UL;
045 return tid;
046 };
047
048 static threadid_t waitnotify() {
049 threadid_t tid;
050 tid.raw = (word_t)-2UL;
051 return tid;
052 };
053
054 static threadid_t anylocalthread( ) {
055 threadid_t tid;
056 tid.raw = (word_t)-64UL;
057 return tid;
058 }
059
060 static threadid_t nilthread()
061 {
062 threadid_t tid;
063 tid.raw = 0;
064 return tid;
065 }
066
067 static threadid_t irqthread(word_ t irq)
068 {
069 threadid_t tid;
070 tid.raw = 0;
071 tid.global.vers ion = 1;
072 tid.global.thre adno = irq;
073 return tid;
074 }
075
076 static threadid_t threadid(word_t threadno, word_t version)
077 {
078 threadid_t tid;
079 tid.raw = 0;
080 tid.global.vers ion = version;
081 tid.global.thre adno = threadno;
082 return tid;
083 }

If it's not enough you can see the entire file at :
http://www.disy.cse.un sw.edu.au/lxr/aos-2006/source/pistachio/kernel/include/api/v4/thread.h#039
I hope it will help you because it donts help me so much ;)
Bye and thanks again.
Antoine

[weaknessforcats]

Your previous post has code like this:

static threadid_t irqthread(word_ t irq)
068 {
069 threadid_t tid;
070 tid.raw = 0;
071 tid.global.vers ion = 1;
072 tid.global.thre adno = irq;
073 return tid;
074 }

Note lines 70, 71 and 72. They show a thread_t has members. That tells me threadid_t cannot fit in a register unless you can show me the definiton of threadid_t so I can see that it is 32 bits or less.

What you are showing me are static functions that return a threadid_t but nowhere to I see the threadid_t itself.

Somewhere, there should be something like:

struct threadid_t
{
      //with members declaredin here
 
};
 

[antoine]

Hi. I think I've found were threadid_t is defined. Here is the code :

private:
    union {
    word_t raw;
 
    struct {
        BITFIELD2( word_t,
               zero    : TID_LOCAL_ID_ZERO_BITS,
               id    : TID_LOCAL_ID_BITS );
    } local;
 
    struct {
        BITFIELD2( word_t,
               version    : TID_GLOBAL_VERSION_BITS,
               threadno    : TID_GLOBAL_THREADNO_BITS );
    } global;
    };
} __attribute__((packed));
 

I've found in another file these definitions :

#if defined(CONFIG_IS_32BIT)
# define L4_ARCH_CONST(const)        const##_32
#elif defined(CONFIG_IS_64BIT)
# define L4_ARCH_CONST(const)        const##_64
#else
# error undefined architecture width (32/64bit?)
#endif
 
#define L4_GLOBAL_THREADNO_BITS_32    18
#define L4_GLOBAL_INTRNO_BITS_32    18
#define L4_GLOBAL_VERSION_BITS_32    14
#define L4_LOCAL_ID_BITS_32        26
#define L4_LOCAL_ID_ZERO_BITS_32    6
#define L4_FPAGE_BASE_BITS_32        22
 
#define L4_GLOBAL_THREADNO_BITS_64    32
#define L4_GLOBAL_INTRNO_BITS_64    32
#define L4_GLOBAL_VERSION_BITS_64    32
#define L4_LOCAL_ID_BITS_64        58
#define L4_LOCAL_ID_ZERO_BITS_64    6
#define L4_FPAGE_BASE_BITS_64        54
 
#define L4_GLOBAL_THREADNO_BITS        L4_ARCH_CONST(L4_GLOBAL_THREADNO_BITS)
#define L4_GLOBAL_INTRNO_BITS        L4_ARCH_CONST(L4_GLOBAL_INTRNO_BITS)
#define L4_GLOBAL_VERSION_BITS        L4_ARCH_CONST(L4_GLOBAL_VERSION_BITS)
#define L4_LOCAL_ID_BITS        L4_ARCH_CONST(L4_LOCAL_ID_BITS)
#define L4_LOCAL_ID_ZERO_BITS        L4_ARCH_CONST(L4_LOCAL_ID_ZERO_BITS)
#define L4_FPAGE_BASE_BITS        L4_ARCH_CONST(L4_FPAGE_BASE_BITS)
 

If I've well understand, the problem is that 32 bits for the number + 32 bits for the version + the word_t doesn't fit in a register ?
But the fact is that these constants does not seem to have precisely the same name (TID_... vs L4...) Have I found the good definitions?
Antoine

[weaknessforcats]

This code:

private:
union {
word_t raw;

struct {
BITFIELD2( word_t,
zero : TID_LOCAL_ID_ZE RO_BITS,
id : TID_LOCAL_ID_BI TS );
} local;

struct {
BITFIELD2( word_t,
version : TID_GLOBAL_VERS ION_BITS,
threadno : TID_GLOBAL_THRE ADNO_BITS );
} global;
};
} __attribute__(( packed));

doesn't say threadid_t anywhere. But assuming this is the declaration, I can see that it is a union of a word_t, a struct local and a struct global.

The threadid_t will be the largest of these three members:

word_t -> I don't know how buig this is
struct local -> has a bitfield member some of the members of the bitfield are defined to be TID_LOCAL_ID_ZE RO_BITS and TID_GLOBAL_THRE ADNO_BITS.

If you find something like:

#define TID_GLOBAL_THRE ADNO_BITS 25

then that bitfield member is 5 bits since 25 only requires 5 bits.

Field members are packed into integers and no field is split between integers.

Have you tried to sizeof(threadid _t) to see how large it is??

I suspect the original processor has a bigger word than your micro kernal 14.

One work around is to use actual integer variables instead of register variables.