src/common/shared.hpp

Idź do dokumentacji tego pliku.

/*header file for src/common/shared.cpp*/

#ifndef _CORE_SHARED_HPP
#define _CORE_SHARED_HPP

//#define _BOCHS


/*
_BOCHS          disable the kernel symtable for faster work

*/

/*all the includes*/
#include "src/common/types.hpp"
#include "src/common/errno.hpp"
#include "src/common/error.hpp"
#include "src/common/profiler.hpp"
#include "src/sandbox.hpp"

#define MIN(a,b)        ({typeof(a) _a = (a); \
                     typeof(b) _b = (b); \
                     _a < _b ? _a : _b;})
//#define MAX(a,b)      ((a) > (b) ? (a) : (b))
#define MAX(a,b)  ({typeof(a) _a = (a); \
                     typeof(b) _b = (b); \
                     _a > _b ? _a : _b;})
#define ABS(a)          ((unsigned typeof(a))( (a) > 0 ? (a) : -(a) ))

#define LOWORD(l)       ((uint16)(uint32)(l))
#define HIWORD(l)       ((uint16)((((uint32)(l))>>16)&0xFFFF))

#define ENTER_CRITICAL(fl) do { asm volatile("pushf\npopl %0\ncli":"=g"(fl));  } while(0)
#define LEAVE_CRITICAL(fl) do { asm volatile("pushl %0\npopf"::"g"(fl)); } while(0)

#include "src/common/println.hpp"



void reboot() __attribute__((noreturn)); 

#define freeze(x) do { lnDbg ; while(1)  asm volatile("cli\nhlt"); } while(0)

inline void print() {}
//inline void print(int x) { kprintf("0x%x", x); }
inline void print(uint32 x) { kprintf("0x%x", x); }
//inline void print(uint64
//inline void print(sint64
#if 0
void print(char n[]);
#endif


template <typename T>
void print(T* v) {
   kprintf("0x%x", reinterpret_cast<uint32>(v));
}

template <>
inline void print<const char>(const char* v) { kprintf("%s", v); }

template <>
inline void print<char>(char *v) { kprintf("%s", v); }


#if 0
inline void print() { }
inline void print(char n[]) { kprintf("%s", n); }

inline void print(uint32 v) {
   kprintf("0x%x", v);
}

#if 1
template<typename T>
inline void print(T* v) {
   print(reinterpret_cast<uint32>(v));
}

#if 1
template<>
inline void print<char>(char* v) {
   kprintf("%s",v);
}
#endif
#endif
#endif


#define null (0)

/*run once code and data, discardable later*/
//#define DISCARDABLE_CODE(X)                                                           
//              X __attribute__((section (".dtext")));                  
//                                                                                                              
//              X

//#define DISCARDABLE_DATA(X)                                                   
//              extern X __attribute__((section (".ddata")));   
//                                                                                                              
//              X ;

// (c) Brendan from megatokyo osdev forums.
// http://www.mega-tokyo.com/forum/index.php?board=1;action=display;threadid=6193
// The following is an infinite loop. Under bochs with a debugger, if you only know the macro has been entered,
// press Ctrl-C to enter the debugger and type "set %ecx = 1" so that the loop ends. You can step further the code then.
// However, this seems to be irrelevant under multithreading/tasking. You may end up in a irq handler.
// Solution: cout a message and cli.
// However, a "pushf cli hlt popf" seems even better.


#define BOCHSHALT __asm__ __volatile__ (      \
   "pushl %ecx\n\t"            \
   "xor %ecx,%ecx\n"         \
   "0:\n\t"               \
   "jecxz 0b\n\t"            \
   "popl %ecx\n\t"            \
)


/*discard runonce data and code*/
//uint32 discard_ddata();               /*data*/
//uint32 discard_dcode();               /*code*/
//void discard_mem();           /*data + code*/

/* definitions */
void dbPrintInt(uint32 n);
void dbSetRow(uint32 n) ;
char digitOfUint(uint32 n, uint32 div);


#endif

---