l4/pkg/l4sys/include/ARCH-arm/kdebug.h

   1 /**
   2  * \file
   3  * \brief   Kernel debugger macros
   4  * \ingroup api_calls
   5  */
   6 /*
   7  * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
   8  *               Alexander Warg <warg@os.inf.tu-dresden.de>
   9  *     economic rights: Technische Universität Dresden (Germany)
  10  *
  11  * This file is part of TUD:OS and distributed under the terms of the
  12  * GNU General Public License 2.
  13  * Please see the COPYING-GPL-2 file for details.
  14  *
  15  * As a special exception, you may use this file as part of a free software
  16  * library without restriction.  Specifically, if other files instantiate
  17  * templates or use macros or inline functions from this file, or you compile
  18  * this file and link it with other files to produce an executable, this
  19  * file does not by itself cause the resulting executable to be covered by
  20  * the GNU General Public License.  This exception does not however
  21  * invalidate any other reasons why the executable file might be covered by
  22  * the GNU General Public License.
  23  */
  24 #pragma once
  25
  26 #include <l4/sys/compiler.h>
  27
  28 #ifdef __GNUC__
  29
  30 #ifndef L4_SYSCALL_MAGIC_OFFSET
  31 #  define L4_SYSCALL_MAGIC_OFFSET       8
  32 #endif
  33 #define L4_SYSCALL_ENTER_KDEBUG         (-0x00000020-L4_SYSCALL_MAGIC_OFFSET)
  34
  35 #define enter_kdebug(text...)                   \
  36 __asm__ __volatile__ (                          \
  37     "   mov     lr, pc          \n"             \
  38     "   mov     pc, %0          \n"             \
  39     "   b       1f              \n"             \
  40     "   .ascii  \"" text "\"    \n"             \
  41     "   .byte   0               \n"             \
  42     "   .align  4               \n"             \
  43     "1:                         \n"             \
  44     :                                           \
  45     : "i" (L4_SYSCALL_ENTER_KDEBUG)             \
  46     : "lr")
  47
  48 L4_INLINE void
  49 outnstring(const char* x, unsigned len) L4_NOTHROW;
  50
  51 L4_INLINE void
  52 outstring(const char *text) L4_NOTHROW;
  53
  54 L4_INLINE void
  55 outchar(char c) L4_NOTHROW;
  56
  57 L4_INLINE void
  58 outdec(int number) L4_NOTHROW;
  59
  60 L4_INLINE void
  61 outhex32(int number) L4_NOTHROW;
  62
  63 L4_INLINE void
  64 outhex20(int number) L4_NOTHROW;
  65
  66 L4_INLINE void
  67 outhex16(int number) L4_NOTHROW;
  68
  69 L4_INLINE void
  70 outhex12(int number) L4_NOTHROW;
  71
  72 L4_INLINE void
  73 outhex8(int number) L4_NOTHROW;
  74
  75 L4_INLINE void
  76 kd_display(char *text) L4_NOTHROW;
  77
  78 L4_INLINE int
  79 l4kd_inchar(void) L4_NOTHROW;
  80
  81 /*
  82  * -------------------------------------------------------------------
  83  * Implementations
  84  */
  85
  86 #define __KDEBUG_ARM_PARAM_0(nr)                                \
  87   ({                                                            \
  88     register unsigned long r0 __asm__("r0");                    \
  89     __asm__ __volatile__                                        \
  90       (                                                         \
  91        "stmdb sp!, {r1-r12,lr}  \n\t"                           \
  92        "mov     lr, pc          \n\t"                           \
  93        "mov     pc, %1          \n\t"                           \
  94        "cmp     lr, #" #nr "    \n\t"                           \
  95        "ldmia sp!, {r1-r12,lr}  \n\t"                           \
  96        :                                                        \
  97        "=r" (r0)                                                \
  98        :                                                        \
  99        "i" (L4_SYSCALL_ENTER_KDEBUG)                            \
 100       );                                                        \
 101     r0;                                                         \
 102   })
 103
 104 #define __KDEBUG_ARM_PARAM_1(nr, p1)                            \
 105   ({                                                            \
 106     register unsigned long r0 __asm__("r0") = (unsigned long)(p1);\
 107     __asm__ __volatile__                                        \
 108       (                                                         \
 109        "stmdb sp!, {r1-r12,lr}  \n\t"                           \
 110        "mov     lr, pc          \n\t"                           \
 111        "mov     pc, %1          \n\t"                           \
 112        "cmp     lr, #" #nr "    \n\t"                           \
 113        "ldmia sp!, {r1-r12,lr}  \n\t"                           \
 114        :                                                        \
 115        "=r" (r0)                                                \
 116        :                                                        \
 117        "i" (L4_SYSCALL_ENTER_KDEBUG),                           \
 118        "0" (r0)                                                 \
 119       );                                                        \
 120     r0;                                                         \
 121   })
 122
 123 #define __KDEBUG_ARM_PARAM_2(nr, p1, p2)                        \
 124   ({                                                            \
 125     register unsigned long r0 __asm__("r0") = (unsigned long)(p1);\
 126     register unsigned long r1 __asm__("r1") = (unsigned long)(p2);\
 127     __asm__ __volatile__                                        \
 128       (                                                         \
 129        "stmdb sp!, {r2-r12,lr}  \n\t"                           \
 130        "mov     lr, pc          \n\t"                           \
 131        "mov     pc, %2          \n\t"                           \
 132        "cmp     lr, #" #nr "    \n\t"                           \
 133        "ldmia sp!, {r2-r12,lr}  \n\t"                           \
 134        :                                                        \
 135        "=r" (r0),                                               \
 136        "=r" (r1)                                                \
 137        :                                                        \
 138        "i" (L4_SYSCALL_ENTER_KDEBUG),                           \
 139        "0" (r0),                                                \
 140        "r" (r1)                                                 \
 141       );                                                        \
 142     r0;                                                         \
 143   })
 144
 145 #define __KDEBUG_ARM_PARAM_3(nr, p1, p2, p3)                    \
 146   ({                                                            \
 147     register unsigned long r0 __asm__("r0") = (unsigned long)(p1);\
 148     register unsigned long r1 __asm__("r1") = (unsigned long)(p2);\
 149     register unsigned long r2 __asm__("r2") = (unsigned long)(p3);\
 150     __asm__ __volatile__                                        \
 151       (                                                         \
 152        "stmdb sp!, {r3-r12,lr}  \n\t"                           \
 153        "mov     lr, pc          \n\t"                           \
 154        "mov     pc, %3          \n\t"                           \
 155        "cmp     lr, #" #nr "    \n\t"                           \
 156        "ldmia sp!, {r3-r12,lr}  \n\t"                           \
 157        :                                                        \
 158        "=r" (r0),                                               \
 159        "=r" (r1),                                               \
 160        "=r" (r2)                                                \
 161        :                                                        \
 162        "i" (L4_SYSCALL_ENTER_KDEBUG),                           \
 163        "0" (r0),                                                \
 164        "r" (r1),                                                \
 165        "r" (r2)                                                 \
 166       );                                                        \
 167     r0;                                                         \
 168   })
 169
 170 #define __KDEBUG_ARM_PARAM_5(nr, p1, p2, p3, p4, p5)            \
 171   ({                                                            \
 172     register unsigned long r0 __asm__("r0") = (unsigned long)(p1);\
 173     register unsigned long r1 __asm__("r1") = (unsigned long)(p2);\
 174     register unsigned long r2 __asm__("r2") = (unsigned long)(p3);\
 175     register unsigned long r3 __asm__("r3") = (unsigned long)(p4);\
 176     register unsigned long r4 __asm__("r4") = (unsigned long)(p5);\
 177     __asm__ __volatile__                                        \
 178       (                                                         \
 179        "stmdb sp!, {r5-r12,lr}  \n\t"                           \
 180        "mov     lr, pc          \n\t"                           \
 181        "mov     pc, %5          \n\t"                           \
 182        "cmp     lr, #" #nr "    \n\t"                           \
 183        "ldmia sp!, {r5-r12,lr}  \n\t"                           \
 184        :                                                        \
 185        "=r" (r0),                                               \
 186        "=r" (r1),                                               \
 187        "=r" (r2),                                               \
 188        "=r" (r3),                                               \
 189        "=r" (r4)                                                \
 190        :                                                        \
 191        "i" (L4_SYSCALL_ENTER_KDEBUG),                           \
 192        "0" (r0),                                                \
 193        "r" (r1),                                                \
 194        "r" (r2),                                                \
 195        "r" (r3),                                                \
 196        "r" (r4)                                                 \
 197       );                                                        \
 198     r0;                                                         \
 199   })
 200
 201
 202 L4_INLINE void
 203 outnstring(const char* x, unsigned len) L4_NOTHROW
 204 {
 205   __asm__ volatile ("" : : : "memory");
 206   __KDEBUG_ARM_PARAM_2(3, x, len);
 207 }
 208
 209 L4_INLINE void
 210 outstring(const char *text) L4_NOTHROW
 211 {
 212   __asm__ volatile("" : : : "memory");
 213   __KDEBUG_ARM_PARAM_1(2, text);
 214 }
 215
 216 L4_INLINE void
 217 outchar(char c) L4_NOTHROW
 218 {
 219   __KDEBUG_ARM_PARAM_1(1, c);
 220 }
 221
 222 L4_INLINE void
 223 outdec(int number) L4_NOTHROW
 224 {
 225   __KDEBUG_ARM_PARAM_1(4, number);
 226 }
 227
 228 L4_INLINE void
 229 outhex32(int number) L4_NOTHROW
 230 {
 231   __KDEBUG_ARM_PARAM_1(5, number);
 232 }
 233
 234 L4_INLINE void
 235 outhex20(int number) L4_NOTHROW
 236 {
 237   __KDEBUG_ARM_PARAM_1(6, number);
 238 }
 239
 240 L4_INLINE void
 241 outhex16(int number) L4_NOTHROW
 242 {
 243   __KDEBUG_ARM_PARAM_1(7, number);
 244 }
 245
 246 L4_INLINE void
 247 outhex12(int number) L4_NOTHROW
 248 {
 249   __KDEBUG_ARM_PARAM_1(8, number);
 250 }
 251
 252 L4_INLINE void
 253 outhex8(int number) L4_NOTHROW
 254 {
 255   __KDEBUG_ARM_PARAM_1(9, number);
 256 }
 257
 258 L4_INLINE void
 259 kd_display(char *text) L4_NOTHROW
 260 {
 261   outstring(text);
 262 }
 263
 264 L4_INLINE int
 265 l4kd_inchar(void) L4_NOTHROW
 266 {
 267   return __KDEBUG_ARM_PARAM_0(0xd);
 268 }
 269
 270 #endif //__GNUC__