l4_types.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef l4_types_h
#define l4_types_h

#include "types.h"

#include "types.h"

//
// INTERFACE definition follows 
//

/*
 * arch. independent L4 Types
 */


typedef Unsigned32 Task_num;

typedef Unsigned32 LThread_num;

typedef Unsigned32 GThread_num;

class L4_uid
{
private:
  enum
  {
    Abs_rcv_mask        = 0x1,
    Abs_snd_mask        = 0x2,
    Abs_rcv_clock       = 0x4,
    Abs_snd_clock       = 0x8,
    Next_period         = 0x10,
    Preemption_id       = 0x20
  };

public:
  enum
  {
    Invalid = 0xffffffff,       
    Nil     = 0x00000000,       
  };

  L4_uid ();

  L4_uid (Address addr, Address tcb_base, Address tcb_size);

  unsigned version() const;

  LThread_num lthread() const;

  GThread_num gthread() const;

  void version( unsigned );

  void lthread( LThread_num );

  Mword is_nil() const;

  Mword is_invalid() const;

  static L4_uid irq( unsigned irq );

  Mword is_irq() const;

  Mword irq() const;

  L4_uid preemption_id() const;

  bool operator == ( L4_uid o ) const;

  bool operator != ( L4_uid o ) const
  { return ! operator == (o); }

  L4_uid (Task_num task, LThread_num lthread);

  Task_num task() const;

  void task (Task_num);

  Task_num chief() const;

  /*
   * Set the chief ID.
   */
  void chief (Task_num);

  /*
   * Get the task ID, the local thread-number is set to 0.
   */
  L4_uid task_id() const;

  bool abs_rcv_timeout() const;

  bool abs_snd_timeout() const;

  bool abs_rcv_clock() const;

  bool abs_snd_clock() const;

  bool next_period() const;

  bool is_preemption() const;

  static unsigned const threads_per_task();

  static Mword const max_threads();
private:

private:
  enum
    {
      Irq_mask           = 0x00000000000000ffULL,
      Low_mask           = 0x00000000ffffffffULL,
      Nil_mask           = Low_mask,
      Version_low_mask   = 0x00000000000003ffULL,
      Version_low_shift  = 0,
      Version_low_size   = 10,
      Lthread_mask       = 0x000000000001fc00ULL,
      Lthread_shift      = Version_low_shift + Version_low_size,
      Lthread_size       = 7,
      Task_mask          = 0x000000000ffe0000ULL,
      Task_shift         = Lthread_shift + Lthread_size,
      Task_size          = 11,
      Version_high_mask  = 0x00000000f0000000ULL,
      Version_high_shift = Task_shift + Task_size,
      Version_high_size  = 4,
      Site_mask          = 0x0001ffff00000000ULL,
      Site_shift         = Version_high_shift + Version_high_size,
      Site_size          = 17,
      Chief_mask         = 0x0ffe000000000000ULL,
      Chief_shift        = Site_shift + Site_size,
      Chief_size         = 11,
      Nest_mask          = 0xf000000000000000ULL,
      Nest_shift         = Chief_shift + Chief_size,
      Nest_size          = 4,
    };

  Unsigned64 _raw;

public:
  enum
    {
      Max_tasks          = 1 << Task_size
    };

  Unsigned64 raw() const;

  L4_uid (Unsigned64);

  L4_uid (Task_num task, LThread_num lthread, unsigned site,
          Task_num chief, unsigned nest = 0, unsigned version = 0);

  unsigned site() const;

  void site (unsigned);

  unsigned nest() const;

  void nest (unsigned);

public:  
  Task_num d_task();
  
  void d_task(Mword num);
  
  LThread_num d_thread();
  
  void d_thread(Mword num);
  
  static inline Unsigned32 lthread_from_gthread(GThread_num g);
  
  static inline Unsigned32 task_from_gthread(GThread_num g);
  
  void print(int task_format = 0) const;
};

typedef L4_uid Global_id;

class L4_snd_desc
{
public:

  L4_snd_desc( Mword w = (Mword)-1 );

  Mword deceite() const;

  Mword map() const;

  void *msg() const;

  Mword is_long_ipc() const;

  Mword is_register_ipc() const;

  Mword has_snd() const;

private:
  Mword _d;

public:  
  inline Mword raw() const;
};


class L4_fpage
{
public:
  L4_fpage (Mword grant, Mword write, Mword order, Mword page);

  L4_fpage( Mword order, Mword page );

  Mword grant() const;

  void grant (Mword g);
  Mword write() const;

  void write( Mword w );

  Mword size() const;

  void size( Mword order );

  Mword page() const;

  void page( Mword base );

  Mword is_whole_space() const;

  Mword is_valid() const;
private:

public:
  enum {
    Whole_io_space = 16, 
    Io_port_max    = 1L << Whole_io_space, 
  };

  static L4_fpage io(Mword port, Mword order, Mword grant);

  Mword iopage() const;

  void iopage( Mword addr );

  Mword is_iopage() const;

  Mword is_whole_io_space() const;

private:
  enum {
    Iopage_mask  = 0x0ffff000,
    Iopage_shift = 12,
    Ioid_mask    = 0xf0000000,
    Io_id        = 0xf0000000,
  };
private:

public:

  typedef Mword Raw;
  typedef Raw Cache_type;

  enum 
  {
    Whole_space = 32, 
  };

  L4_fpage(Raw w = 0);

  Raw raw() const;

private:

  Raw _raw;

  enum 
  { 
    /* +--- 32-12 ---+ 11-10 +- 9-8 -+- 7-2 + 1 + 0 +
     * | page number |   C   | unused | size | W | G |
     * +-------------+-------+--------+------+---+---+ */
    Grant_bit        = 0, 
    Write_bit        = 1, 
    Size_mask        = 0x000000fc,
    Size_shift       = 2,
    Size_size        = 6,
    Cache_type_mask  = 0x00000c00,
    Page_mask        = 0xfffff000,
    Page_shift       = 0,
    Page_size        = 32,
  };


public:  
  inline L4_fpage::Cache_type cache_type() const;
};


class L4_rcv_desc
{
public:

  static L4_rcv_desc short_fpage (L4_fpage fp);

  L4_rcv_desc( Mword w = (Mword)-1 );

  Mword open_wait() const;

  Mword rmap() const;

  void *msg() const;

  L4_fpage fpage() const;

  Mword is_register_ipc() const;

  Mword has_receive() const;

private:
  Mword _d;


public:  
  inline Mword raw() const;
};


class Ipc_err
{
public:
  Ipc_err( Mword raw = 0 );

  Mword raw() const;

  Mword deceited() const;

  Mword fpage_received() const;

  void fpage_received( Mword f );

  Mword redirected() const;

  Mword src_inside() const;

  Mword snd_error() const;

  Mword error() const;

  void error( Mword error );

  Mword has_error() const;

  const char * str_error() const;

  Mword rcv_map_failed() const;

  Mword snd_map_failed() const;

  void combine( Ipc_err other );

  enum
    {
      Send_error    =           0x10,
      Enot_existent =           0x10, 
      Retimeout     =           0x20, 
      Setimeout     =           0x30, 
      Recanceled    =           0x40, 
      Secanceled    =           0x50, 
      Remapfailed   =           0x60, 
      Semapfailed   =           0x70, 
      Resndpfto     =           0x80, 
      Sesndpfto     =           0x90, 
      Rercvpfto     =           0xA0, 
      Sercvpfto     =           0xB0, 
      Reaborted     =           0xC0, 
      Seaborted     =           0xD0, 
      Remsgcut      =           0xE0, 
      Semsgcut      =           0xF0, 
    };

private:
  enum
    {
      Deceite_bit      = 0,
      Fpage_bit        = 1,
      Redirected_bit   = 2,
      Src_inside_bit   = 3,
      Snd_error_bit    = 4,
      Error_code_shift = 5,
      Error_code_mask  = 0x7L << Error_code_shift,
      Error_code_size  = 3,
      Error_shift      = 4,
      Error_mask       = 0xfL << Error_shift,
      Error_size       = 4,
      Cc_mask          = 0xFF,
    };

  Mword _raw;
};
  

class L4_msgdope
{
public:
  enum {
    Send_error    =             0x10, 
    Enot_existent =             0x10, 
    Retimeout     =             0x20, 
    Setimeout     =             0x30, 
    Recanceled    =             0x40, 
    Secanceled    =             0x50, 
    Remapfailed   =             0x60, 
    Semapfailed   =             0x70, 
    Resndpfto     =             0x80, 
    Sesndpfto     =             0x90, 
    Rercvpfto     =             0xA0, 
    Sercvpfto     =             0xB0, 
    Reaborted     =             0xC0, 
    Seaborted     =             0xD0, 
    Remsgcut      =             0xE0, 
    Semsgcut      =             0xF0, 
  };

  L4_msgdope( Mword raw = 0 );

  L4_msgdope( Mword mwords, Mword strings );

  L4_msgdope (Ipc_err e);

  Mword raw() const;

  Mword raw_dope() const;

  Mword deceited() const;

  Mword fpage_received() const;

  void fpage_received( Mword f );

  Mword redirected() const;

  Mword src_inside() const;

  Mword snd_error() const;

  Mword error() const;

  void error( Mword error );

  Mword has_error() const;

  const char * str_error() const;

  Mword strings() const;

  void strings( Mword s );

  Mword mwords() const;

  void mwords( Mword w );

  Mword rcv_map_failed() const;

  Mword snd_map_failed() const;

  void combine( L4_msgdope other );

  void combine( Ipc_err e );

private:
  Mword _raw;
  enum {
    Deceite_bit      = 0,
    Fpage_bit        = 1,
    Redirected_bit   = 2,
    Src_inside_bit   = 3,
    Snd_error_bit    = 4,
    Error_code_shift = 5,
    Error_code_mask  = 0x7L << Error_code_shift,
    Error_code_size  = 3,
    Error_shift      = 4,
    Error_mask       = 0xfL << Error_shift,
    Error_size       = 4,
    Strings_shift    = Error_code_shift + Error_code_size,
    Strings_mask     = 0x1fL << Strings_shift,
    Strings_size     = 5,
    Mwords_shift     = Strings_shift + Strings_size,
    Mwords_mask      = 0x7ffffL << Mwords_shift,
    Mwords_size      = 19,
    Dope_mask        = Strings_mask | Mwords_mask,
  };

};


class L4_str_dope 
{
public:
  Mword snd_size;

  Unsigned8 *snd_str;

  Mword rcv_size;

  Unsigned8 *rcv_str;
};


class L4_timeout
{
public:
  enum {
    Never = 0, 
  };

  L4_timeout (Mword snd_man, Mword snd_exp, 
              Mword rcv_man, Mword rcv_exp, 
              Mword snd_pflt, Mword rcv_pflt);

  Mword rcv_pfault() const;

  void rcv_pfault (Mword pr);

  Mword snd_pfault() const;

  void snd_pfault (Mword ps);
  explicit L4_timeout( Mword t = 0 );

  Mword raw();

  Mword rcv_exp() const;

  void rcv_exp( Mword er );

  Mword rcv_man() const;

  void rcv_man( Mword mr );

  Mword snd_exp() const;

  void snd_exp( Mword es );

  Mword snd_man() const;

  void snd_man( Mword ms );

  Unsigned64 rcv_microsecs_rel (Unsigned64 clock) const;

  Unsigned64 snd_microsecs_rel (Unsigned64 clock) const;

  Unsigned64 rcv_microsecs_abs (Unsigned64 clock, bool c) const;

  Unsigned64 snd_microsecs_abs (Unsigned64 clock, bool c) const;

private:
  enum
    {
      Rcv_exp_mask     = 0xf,
      Rcv_exp_shift    = 0,

      Snd_exp_mask     = 0xf0,
      Snd_exp_shift    = 4,

      Rcv_pfault_mask  = 0xf00,
      Rcv_pfault_shift = 8,

      Snd_pfault_mask  = 0xf000,
      Snd_pfault_shift = 12,

      Snd_man_mask     = 0xff0000,
      Snd_man_shift    = 16,

      Rcv_man_mask     = 0xff000000,
      Rcv_man_shift    = 24,
    };

  Mword _t;
};


class L4_sched_param
{
public:

  L4_sched_param( Mword raw = 0 );

  Mword is_valid() const;

  Mword prio() const;

  void prio( Mword p );

  Mword small() const;

  void small( Mword s );

  Mword mode() const;

  void thread_state( Mword s );

  void time( Unsigned64 t );

  Unsigned64 time();

  Mword time_exp() const;

  void time_exp( Mword e );

  Mword time_man() const;

  void time_man( Mword m );

  Mword raw() const;

private:

  Mword _raw;

  enum {
    Prio_shift     = 0,
    Prio_mask      = 0x0ff,
    Prio_size      = 8,
    Small_shift    = Prio_size + Prio_shift,
    Small_size     = 8,
    Small_mask     = ((1UL << Small_size) - 1) << Small_shift,
    Mode_shift     = Small_shift + Small_size,
    Mode_size      = 4,
    Mode_mask      = ((1UL << Mode_size) - 1) << Mode_shift,
    Time_exp_shift = Mode_shift + Mode_size, 
    Time_exp_size  = 4,
    Time_exp_mask  = ((1UL << Time_exp_size) - 1) << Time_exp_shift,
    Time_man_shift = Time_exp_size + Time_exp_shift,
    Time_man_size  = 8,
    Time_man_mask  = ((1UL << Time_man_size) - 1) << Time_man_shift,
  };

};

class L4_pipc
{
private:
  enum
    {
      Clock_shift        = 0,
      Id_shift           = 56,
      Lost_shift         = 62,
      Type_shift         = 63,
      Clock_mask         = 0x00ffffffffffffffULL,
      Id_mask            = 0x3f00000000000000ULL,
      Lost_mask          = 0x4000000000000000ULL,
      Type_mask          = 0x8000000000000000ULL,
      Low_shift          = 0,
      High_shift         = 32,
      Low_mask           = 0x00000000ffffffffULL,
      High_mask          = 0xffffffff00000000ULL
    };

  Unsigned64 _raw;

public:
  Mword low() const;

  Mword high() const;

  L4_pipc (unsigned type, unsigned lost, unsigned id, Cpu_time clock);
};


class L4_exception_ipc
{
public:
  enum
  {
    Exception_ipc_cookie_1 = Mword(-0x5),
    Exception_ipc_cookie_2 = Mword(-0x21504151),
  };
};


//----------------------------------------------------------------------------

  
typedef void Utcb;      
typedef L4_uid Local_id;

//
// IMPLEMENTATION of inline functions (and needed classes)
//




inline Unsigned32
L4_uid::lthread_from_gthread(GThread_num g)
{
  return g % threads_per_task();
}



inline Unsigned32
L4_uid::task_from_gthread(GThread_num g)
{
  return g / threads_per_task();
}


//
// L4_uid implementation
//

inline L4_uid::L4_uid()
{}


inline bool L4_uid::abs_rcv_timeout() const
{ return chief() & Abs_rcv_mask; }

 
inline bool L4_uid::abs_snd_timeout() const
{ return chief() & Abs_snd_mask; }

 
inline bool L4_uid::abs_rcv_clock() const
{ return chief() & Abs_rcv_clock; }

 
inline bool L4_uid::abs_snd_clock() const
{ return chief() & Abs_snd_clock; }


inline bool L4_uid::next_period() const
{ return chief() & Next_period; }


inline bool L4_uid::is_preemption() const
{ return chief() & Preemption_id; }



inline L4_uid
L4_uid::preemption_id() const
{
  L4_uid id (_raw);
  id.chief (Preemption_id);
  return id;
}


inline unsigned const L4_uid::threads_per_task()
{ return 1 << Lthread_size; }

 
inline bool L4_uid::operator == (L4_uid o) const
{ return o._raw == _raw; }


inline Mword const L4_uid::max_threads()
{ return 1 << (Task_size + Lthread_size); }


inline Mword L4_uid::irq() const
{ return _raw - 1; }


inline L4_uid L4_uid::irq(unsigned irq)
{ return L4_uid ((irq + 1) & Irq_mask); }


inline Mword L4_uid::is_irq() const
{ return (_raw & ~Irq_mask) == 0 && _raw; }


inline L4_uid L4_uid::task_id() const
{ return L4_uid (_raw & ~Lthread_mask); }


inline Mword L4_uid::is_nil() const
{ return (_raw & Nil_mask) == 0; }


inline Mword L4_uid::is_invalid() const
{ return (_raw & Low_mask) == Invalid; }



inline L4_uid::L4_uid(Unsigned64 w)
      : _raw (w)
{}



inline L4_uid::L4_uid(Task_num task, LThread_num lthread)
      : _raw ((((Unsigned64) task    << Task_shift)    & Task_mask) |
              (((Unsigned64) lthread << Lthread_shift) & Lthread_mask))
{}

  

inline L4_uid::L4_uid(Task_num task, LThread_num lthread, unsigned site,
                Task_num chief, unsigned nest, unsigned version) 
  : _raw ((((Unsigned64) task    << Task_shift)         & Task_mask)        |
          (((Unsigned64) lthread << Lthread_shift)      & Lthread_mask)     |
          (((Unsigned64) site    << Site_shift)         & Site_mask)        |
          (((Unsigned64) chief   << Chief_shift)        & Chief_mask)       |
          (((Unsigned64) nest    << Nest_shift)         & Nest_mask)        |
          (((Unsigned64) version << Version_low_shift)  & Version_low_mask) |
          (((Unsigned64) version << Version_high_shift) & Version_high_mask))
{}


inline Unsigned64 L4_uid::raw() const
{ return _raw; }



inline unsigned
L4_uid::version() const
{
  return ((_raw & Version_high_mask) >> Version_high_shift) |
         ((_raw & Version_low_mask ) >> Version_low_shift);
}



inline void
L4_uid::version(unsigned w)
{
  _raw = (_raw & ~(Version_low_mask | Version_high_mask)) |
         (((Unsigned64) w << Version_low_shift)  & Version_low_mask) |
         (((Unsigned64) w << Version_high_shift) & Version_high_mask);
}



inline LThread_num
L4_uid::lthread() const  
{
  // both casts (_raw and Lthread_mask) to unsigned are hints for gcc
  return ((unsigned) _raw & (unsigned) Lthread_mask) >> Lthread_shift;
}



inline void
L4_uid::lthread(LThread_num w)
{
  _raw = (_raw & ~Lthread_mask) |
         (((Unsigned64) w << Lthread_shift) & Lthread_mask);
}



inline Task_num
L4_uid::task() const
{
  // both casts (_raw and Task_mask) to unsigned are hints for gcc
  return ((unsigned) _raw & (unsigned) Task_mask) >> Task_shift;
}



inline void
L4_uid::task(Task_num w)
{
  _raw = (_raw & ~Task_mask) |
         (((Unsigned64) w << Task_shift) & Task_mask);
}



inline Task_num
L4_uid::chief() const
{
  return (_raw & Chief_mask) >> Chief_shift;
}



inline void
L4_uid::chief(Task_num w)
{
  _raw = (_raw & ~Chief_mask) |
         (((Unsigned64) w << Chief_shift) & Chief_mask);
}



inline unsigned
L4_uid::site() const
{
  return (_raw & Site_mask) >> Site_shift;
}



inline void
L4_uid::site(unsigned w)
{
  _raw = (_raw & ~Site_mask) | (((Unsigned64) w << Site_shift) & Site_mask);
}

 

inline unsigned
L4_uid::nest() const
{
  return (_raw & Nest_mask) >> Nest_shift;
}



inline void
L4_uid::nest(unsigned w)
{
  _raw = (_raw & ~Nest_mask) | (((Unsigned64) w << Nest_shift) & Nest_mask);
}



inline GThread_num
L4_uid::gthread() const
{
  // both casts (_raw and {LTHREAD,TASK}_MASK) to unsigned are hints for gcc
  return (((unsigned) _raw & (unsigned) Lthread_mask) >> Lthread_shift) |
         (((unsigned) _raw & (unsigned) Task_mask   ) >> (Task_shift - 
                                                          Lthread_size));
}



inline L4_uid::L4_uid(Address addr, Address tcb_base, Address tcb_size)
      : _raw ( ((addr - tcb_base) / tcb_size) << Lthread_shift )
{}


inline Mword L4_snd_desc::raw() const
{ return _d; }


//
// L4_snd_desc implementation
//

inline L4_snd_desc::L4_snd_desc( Mword w )
  : _d(w)
{}

  
inline Mword L4_snd_desc::deceite() const
{ return _d & 1; }


inline Mword L4_snd_desc::map() const
{ return _d & 2; }


inline Mword L4_snd_desc::is_long_ipc() const
{ return _d & ~1; }


inline Mword L4_snd_desc::is_register_ipc() const
{ return (_d & ~1) == 0; }


inline Mword L4_snd_desc::has_snd() const
{ return _d != (Mword)-1; }


inline void *L4_snd_desc::msg() const
{ return (void*)(_d & ~3); }



inline L4_fpage::Cache_type
L4_fpage::cache_type() const
{ return _raw & Cache_type_mask; }



inline Mword L4_fpage::is_iopage() const
{
  return (_raw & Ioid_mask) == Io_id;
}



inline void L4_fpage::iopage( Mword w )
{
  _raw = (_raw & ~Iopage_mask) | ((w << Iopage_shift) & Iopage_mask);
}



inline Mword L4_fpage::iopage() const
{
  return (_raw & Iopage_mask) >> Iopage_shift;
}



inline L4_fpage L4_fpage::io( Mword port, Mword size, Mword grant )
{
  return L4_fpage( (grant ? 1 : 0) 
                   | ((port << Iopage_shift) & Iopage_mask)
                   | ((size << Size_shift) & Size_mask)
                   | Io_id);
}



inline Mword L4_fpage::is_whole_io_space() const
{
  return (_raw >> 2) == Whole_io_space;
}



inline Mword 
L4_fpage::is_valid() const
{ return _raw; }



inline L4_fpage::L4_fpage(Raw raw)
  : _raw(raw)
{}



inline L4_fpage::L4_fpage(Mword grant, Mword write, Mword size, Mword page)
  : _raw((grant ? (1<<Grant_bit) : 0)
         | (write ? (1<<Write_bit) : 0)
         | ((size << Size_shift) & Size_mask)
         | ((page << Page_shift) & Page_mask))
{}



inline L4_fpage::L4_fpage(Mword size, Mword page)
  : _raw(((size << Size_shift) & Size_mask)
         | ((page << Page_shift) 
            & Page_mask))
{}



inline Mword 
L4_fpage::grant() const
{ return _raw & (1<<Grant_bit); }



inline Mword
L4_fpage::write() const
{ return _raw & (1<<Write_bit); }



inline Mword
L4_fpage::size() const
{ return (_raw & Size_mask) >> Size_shift; }



inline Mword
L4_fpage::page() const
{ return (_raw & Page_mask) >> Page_shift; }



inline void 
L4_fpage::grant(Mword w)
{
  if(w)
    _raw |= (1<<Grant_bit);
  else
    _raw &= ~(1<<Grant_bit);
}



inline void 
L4_fpage::write(Mword w)
{
  if(w)
    _raw |= (1<<Write_bit);
  else
    _raw &= ~(1<<Write_bit);
}



inline void 
L4_fpage::size(Mword w)
{ _raw = (_raw & ~Size_mask) | ((w<<Size_shift) & Size_mask); }



inline void 
L4_fpage::page(Mword w)
{ _raw = (_raw & ~Page_mask) | ((w<<Page_shift) & Page_mask); }



inline L4_fpage::Raw
L4_fpage::raw() const
{ return _raw; }



inline Mword
L4_fpage::is_whole_space() const
{ return (_raw >> 2) == 32; }


inline Mword L4_rcv_desc::raw() const
{ return _d; }


//
// L4_rcv_desc implementation
//

inline L4_rcv_desc L4_rcv_desc::short_fpage(L4_fpage fp)
{ return L4_rcv_desc( 2 /*rmap*/ | (fp.raw() & ~3) ); }


inline L4_rcv_desc::L4_rcv_desc( Mword w)
  : _d(w)
{}


inline Mword L4_rcv_desc::open_wait() const
{ return _d & 1; }


inline Mword L4_rcv_desc::rmap() const
{ return _d & 2; }


inline void *L4_rcv_desc::msg() const
{ return (void*)(_d & ~3); }


inline L4_fpage L4_rcv_desc::fpage() const
{ return L4_fpage( _d & ~3 ); }


inline Mword L4_rcv_desc::is_register_ipc() const
{ return (_d & ~1) == 0; }

  
inline Mword L4_rcv_desc::has_receive() const
{ return _d != (Mword)-1; }



//
// Ipc_err implementation
//

inline Ipc_err::Ipc_err(Mword raw)
       : _raw (raw & Cc_mask)
{}


inline Mword Ipc_err::raw() const
{ return _raw; }


inline Mword Ipc_err::deceited() const
{ return _raw & (1 << Deceite_bit); }


inline Mword Ipc_err::fpage_received() const
{ return _raw & (1 << Fpage_bit); }


inline Mword Ipc_err::redirected() const
{ return _raw & (1 << Redirected_bit); }


inline Mword Ipc_err::src_inside() const
{ return _raw & (1 << Src_inside_bit); }


inline Mword
Ipc_err::snd_error() const
{ return _raw & (1 << Snd_error_bit); }


inline Mword Ipc_err::has_error() const
{ return _raw & Error_mask; }


inline Mword Ipc_err::error() const
{ return _raw & Error_mask; }


inline Mword Ipc_err::rcv_map_failed() const
{ return (_raw & Error_mask) == Remapfailed; }


inline Mword Ipc_err::snd_map_failed() const
{ return (_raw & Error_mask) == Semapfailed; }


inline void Ipc_err::error(Mword e)
{ _raw = (_raw & ~Error_mask) | (e & Error_mask); }



inline void
Ipc_err::fpage_received(Mword w)
{
  if (w)
    _raw |= (1L << Fpage_bit);
  else
    _raw &= ~(1L << Fpage_bit);
}


inline void Ipc_err::combine(Ipc_err o)
{ _raw = (_raw & ~Error_mask) | o._raw; }


//
// L4_msgdope implementation
//

inline L4_msgdope::L4_msgdope(Mword mwords, Mword strings)
  : _raw( ((strings << Strings_shift) & Strings_mask)
          |((mwords << Mwords_shift) & Mwords_mask) )
{}



inline L4_msgdope::L4_msgdope( Mword raw )
  : _raw(raw)
{}



inline L4_msgdope::L4_msgdope(Ipc_err e)
  : _raw (e.raw())
{}


inline Mword L4_msgdope::raw() const
{ return _raw; }


inline Mword L4_msgdope::raw_dope() const
{return _raw & Dope_mask;}


inline Mword L4_msgdope::deceited() const
{ return _raw & (1 << Deceite_bit); }


inline Mword L4_msgdope::fpage_received() const
{ return _raw & (1 << Fpage_bit); }


inline Mword L4_msgdope::redirected() const
{ return _raw & (1 << Redirected_bit); }


inline Mword L4_msgdope::src_inside() const
{ return _raw & (1 << Src_inside_bit); }


inline Mword L4_msgdope::snd_error() const
{ return _raw & (1 << Snd_error_bit); }


inline Mword L4_msgdope::strings() const
{ return (_raw & Strings_mask) >> Strings_shift; }


inline Mword L4_msgdope::mwords() const
{ return (_raw & Mwords_mask) >> Mwords_shift; }


inline void L4_msgdope::mwords( Mword w )
{ _raw = (_raw & ~Mwords_mask) | ((w << Mwords_shift) & Mwords_mask); }


inline void L4_msgdope::strings( Mword w )
{ _raw = (_raw & ~Strings_mask) | ((w << Strings_shift) & Strings_mask); }


inline Mword L4_msgdope::has_error() const
{ return _raw & Error_mask; }


inline Mword L4_msgdope::error() const
{ return _raw & Error_mask; }


inline Mword L4_msgdope::rcv_map_failed() const
{ return (_raw & Error_mask) == Remapfailed; }


inline Mword L4_msgdope::snd_map_failed() const
{ return (_raw & Error_mask) == Semapfailed; }


inline void L4_msgdope::error(Mword e)
{ _raw = (_raw & ~Error_mask) | (e & Error_mask); }



inline void
L4_msgdope::fpage_received( Mword w )
{
  if(w)
    _raw |= (1L << Fpage_bit);
  else
    _raw &= ~(1L << Fpage_bit);
}


inline void L4_msgdope::combine( L4_msgdope o )
{ _raw = (_raw & ~Error_mask) | o._raw; }


inline void L4_msgdope::combine( Ipc_err e )
{ _raw = (_raw & ~Error_mask) | e.raw(); }


//
// L4_timeout implementation
//

inline L4_timeout::L4_timeout(Mword t)
  : _t(t)
{}


inline Mword L4_timeout::raw()
{ return _t; }



inline Unsigned64
L4_timeout::rcv_microsecs_rel(Unsigned64 clock) const
{ return clock + ((Unsigned64) (rcv_man()) << ((15 - rcv_exp()) << 1)); }



inline Unsigned64
L4_timeout::snd_microsecs_rel(Unsigned64 clock) const
{ return clock + ((Unsigned64) (snd_man()) << ((15 - snd_exp()) << 1)); }



inline Unsigned64
L4_timeout::rcv_microsecs_abs(Unsigned64 clock, bool c) const
{
  Mword e = 15 - rcv_exp();
  Unsigned64 timeout = clock & ~((1 << e + 8) - 1) | rcv_man() << e;

  if (((clock >> e + 8) & 1) != c)
    timeout += 1 << e + 8;

  if (timeout > clock + (1 << e + 8))
    timeout -= 1 << e + 9;

  return timeout;
}



inline Unsigned64
L4_timeout::snd_microsecs_abs(Unsigned64 clock, bool c) const
{
  Mword e = 15 - snd_exp();
  Unsigned64 timeout = clock & ~((1 << e + 8) - 1) | snd_man() << e;

  if (((clock >> e + 8) & 1) != c)
    timeout += 1 << e + 8;

  if (timeout > clock + (1 << e + 8))
    timeout -= 1 << e + 9;

  return timeout;
}



//
// L4_timeout implementation
//

inline L4_timeout::L4_timeout(Mword snd_man, Mword snd_exp, 
                        Mword rcv_man, Mword rcv_exp, 
                        Mword snd_pflt, Mword rcv_pflt)
          : _t (((snd_man << Snd_man_shift) & Snd_man_mask) |
                ((snd_exp << Snd_exp_shift) & Snd_exp_mask) |
                ((rcv_man << Rcv_man_shift) & Rcv_man_mask) |
                ((rcv_exp << Rcv_exp_shift) & Rcv_exp_mask) |
                ((rcv_pflt << Rcv_pfault_shift) & Rcv_pfault_mask) |
                ((snd_pflt << Snd_pfault_shift) & Snd_pfault_mask))
{}

 
inline Mword L4_timeout::rcv_exp() const
{ return (_t & Rcv_exp_mask) >> Rcv_exp_shift; }


inline void L4_timeout::rcv_exp(Mword w)
{ _t = (_t & ~Rcv_exp_mask) | ((w << Rcv_exp_shift) & Rcv_exp_mask); }

 
inline Mword L4_timeout::snd_exp() const
{ return (_t & Snd_exp_mask) >> Snd_exp_shift; }


inline void L4_timeout::snd_exp(Mword w)
{ _t = (_t & ~Snd_exp_mask) | ((w << Snd_exp_shift) & Snd_exp_mask); }


inline Mword L4_timeout::rcv_pfault() const
{ return (_t & Rcv_pfault_mask) >> Rcv_pfault_shift; }


inline void L4_timeout::rcv_pfault(Mword w)
{ _t = (_t & ~Rcv_pfault_mask) | ((w << Rcv_pfault_shift) & Rcv_pfault_mask); }


inline Mword L4_timeout::snd_pfault() const
{ return (_t & Snd_pfault_mask) >> Snd_pfault_shift; }


inline void L4_timeout::snd_pfault(Mword w)
{ _t = (_t & ~Snd_pfault_mask) | ((w << Snd_pfault_shift) & Snd_pfault_mask); }


inline Mword L4_timeout::rcv_man() const
{ return (_t & Rcv_man_mask) >> Rcv_man_shift; }


inline void L4_timeout::rcv_man(Mword w)
{ _t = (_t & ~Rcv_man_mask) | ((w << Rcv_man_shift) & Rcv_man_mask); }


inline Mword L4_timeout::snd_man() const
{ return (_t & Snd_man_mask) >> Snd_man_shift; }


inline void L4_timeout::snd_man(Mword w)
{ _t = (_t & ~Snd_man_mask) | ((w << Snd_man_shift) & Snd_man_mask); }


//
// L4_sched_param implementation
//

inline L4_sched_param::L4_sched_param( Mword raw )
  : _raw(raw)
{}


inline Mword L4_sched_param::prio() const
{ return (_raw & Prio_mask) >> Prio_shift; }


inline void L4_sched_param::prio( Mword p )
{ _raw = (_raw & ~Prio_mask) | ((p << Prio_shift) & Prio_mask); }


inline Mword L4_sched_param::small() const
{ return (_raw & Small_mask) >> Small_shift; }


inline void L4_sched_param::small( Mword s )
{ _raw = (_raw & ~Small_mask) | ((s << Small_shift) & Small_mask); }


inline Mword L4_sched_param::time_exp() const
{ return (_raw & Time_exp_mask) >> Time_exp_shift; }


inline void L4_sched_param::time_exp( Mword e )
{ _raw = (_raw & ~Time_exp_mask) | ((e << Time_exp_shift) & Time_exp_mask); }


inline Mword L4_sched_param::time_man() const
{ return (_raw & Time_man_mask) >> Time_man_shift; }


inline void L4_sched_param::time_man( Mword m )
{ _raw = (_raw & ~Time_man_mask) | ((m << Time_man_shift) & Time_man_mask); }


inline Mword L4_sched_param::mode() const
{ return (_raw & Mode_mask) >> Mode_shift; }


inline void L4_sched_param::thread_state( Mword e )
{ _raw = (_raw & ~Mode_mask) | ((e << Mode_shift) & Mode_mask); }


inline Mword L4_sched_param::raw() const
{ return _raw; }


inline Mword L4_sched_param::is_valid() const
{ return _raw != (Mword)-1; }



inline void
L4_sched_param::time(Unsigned64 t)
{
  Mword exp = 15;
  while (t > 255)
    {
      t >>= 2;
      exp--;
    }

  time_exp(exp);
  time_man(t);
}



inline Unsigned64
L4_sched_param::time()
{
  if(time_exp())
    {
      if(time_man())
        return (Unsigned64)time_man() << ((15-time_exp()) << 1);
      else
        return 0;
    }
  else
    return (Unsigned64)-1;
}


//
// L4_pipc implementation
//

inline L4_pipc::L4_pipc(unsigned type, unsigned lost, unsigned id, Cpu_time clock)
       : _raw ( (((Unsigned64) type  << Type_shift)  & Type_mask) |
                (((Unsigned64) lost  << Lost_shift)  & Lost_mask) |
                (((Unsigned64) id    << Id_shift)    & Id_mask)   |
                (((Unsigned64) clock << Clock_shift) & Clock_mask))
{}


inline Mword L4_pipc::low() const
{ return (_raw & Low_mask) >> Low_shift; }


inline Mword L4_pipc::high() const
{ return (_raw & High_mask) >> High_shift; }

#endif // l4_types_h

---