| 1 | /* |
| 2 | * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. |
| 3 | * |
| 4 | * This software may be freely used, copied, modified, and distributed |
| 5 | * provided that the above copyright notice is preserved in all copies of the |
| 6 | * software. |
| 7 | */ |
| 8 | |
| 9 | /* -*-C-*- |
| 10 | * |
| 11 | * $Revision$ |
| 12 | * $Date$ |
| 13 | * |
| 14 | * |
| 15 | * logging.c - methods for logging warnings, errors and trace info |
| 16 | * |
| 17 | */ |
| 18 | |
| 19 | #include <stdarg.h> /* ANSI varargs support */ |
| 20 | |
| 21 | #ifdef TARGET |
| 22 | # include "angel.h" |
| 23 | # include "devconf.h" |
| 24 | #else |
| 25 | # include "host.h" |
| 26 | #endif |
| 27 | |
| 28 | #include "logging.h" /* Header file for this source code */ |
| 29 | |
| 30 | #ifndef UNUSED |
| 31 | # define UNUSED(x) ((x)=(x)) |
| 32 | #endif |
| 33 | |
| 34 | /* |
| 35 | * __rt_warning |
| 36 | * ------------ |
| 37 | * This routine is provided as a standard method of generating |
| 38 | * run-time system warnings. The actual action taken by this code can |
| 39 | * be board or target application specific, e.g. internal logging, |
| 40 | * debug message, etc. |
| 41 | */ |
| 42 | |
| 43 | #ifdef DEBUG |
| 44 | |
| 45 | # ifdef DEBUG_METHOD |
| 46 | |
| 47 | # define STRINGIFY2(x) #x |
| 48 | # define STRINGIFY(x) STRINGIFY2(x) |
| 49 | # define DEBUG_METHOD_HEADER STRINGIFY(DEBUG_METHOD##.h) |
| 50 | |
| 51 | # include DEBUG_METHOD_HEADER |
| 52 | |
| 53 | # define METHOD_EXPAND_2(m, p, c) m##p(c) |
| 54 | # define METHOD_EXPAND(m, p, c) METHOD_EXPAND_2(m, p, c) |
| 55 | |
| 56 | # define CHAROUT(c) METHOD_EXPAND(DEBUG_METHOD, _PutChar, (c)) |
| 57 | # define PRE_DEBUG(l) METHOD_EXPAND(DEBUG_METHOD, _PreWarn, (l)) |
| 58 | # define POST_DEBUG(n) METHOD_EXPAND(DEBUG_METHOD, _PostWarn, (n)) |
| 59 | |
| 60 | # else |
| 61 | # error Must define DEBUG_METHOD |
| 62 | # endif |
| 63 | |
| 64 | #endif /* def DEBUG */ |
| 65 | |
| 66 | /* |
| 67 | * the guts of __rt_warning |
| 68 | */ |
| 69 | |
| 70 | #pragma no_check_stack |
| 71 | #ifdef DEBUG |
| 72 | |
| 73 | static const char hextab[] = "0123456789ABCDEF"; |
| 74 | |
| 75 | /* |
| 76 | * If debugging, then we break va_warn into sub-functions which |
| 77 | * allow us to get an easy breakpoint on the formatted string |
| 78 | */ |
| 79 | static int va_warn0(char *format, va_list args) |
| 80 | { |
| 81 | int len = 0; |
| 82 | |
| 83 | while ((format != NULL) && (*format != '\0')) |
| 84 | { |
| 85 | if (*format == '%') |
| 86 | { |
| 87 | char fch = *(++format); /* get format character (skipping '%') */ |
| 88 | int ival; /* holder for integer arguments */ |
| 89 | char *string; /* holder for string arguments */ |
| 90 | int width = 0; /* No field width by default */ |
| 91 | int padzero = FALSE; /* By default we pad with spaces */ |
| 92 | |
| 93 | /* |
| 94 | * Check if the format has a width specified. NOTE: We do |
| 95 | * not use the "isdigit" function here, since it will |
| 96 | * require run-time support. The current ARM Ltd header |
| 97 | * defines "isdigit" as a macro, that uses a fixed |
| 98 | * character description table. |
| 99 | */ |
| 100 | if ((fch >= '0') && (fch <= '9')) |
| 101 | { |
| 102 | if (fch == '0') |
| 103 | { |
| 104 | /* Leading zeroes padding */ |
| 105 | padzero = TRUE; |
| 106 | fch = *(++format); |
| 107 | } |
| 108 | |
| 109 | while ((fch >= '0') && (fch <= '9')) |
| 110 | { |
| 111 | width = ((width * 10) + (fch - '0')); |
| 112 | fch = *(++format); |
| 113 | } |
| 114 | } |
| 115 | |
| 116 | if (fch == 'l') |
| 117 | /* skip 'l' in "%lx", etc. */ |
| 118 | fch = *(++format); |
| 119 | |
| 120 | switch (fch) |
| 121 | { |
| 122 | case 'c': |
| 123 | /* char */ |
| 124 | ival = va_arg(args, int); |
| 125 | CHAROUT((char)ival); |
| 126 | len++; |
| 127 | break; |
| 128 | |
| 129 | case 'x': |
| 130 | case 'X': |
| 131 | { |
| 132 | /* hexadecimal */ |
| 133 | unsigned int uval = va_arg(args, unsigned int); |
| 134 | int loop; |
| 135 | |
| 136 | UNUSED(uval); |
| 137 | |
| 138 | if ((width == 0) || (width > 8)) |
| 139 | width = 8; |
| 140 | |
| 141 | for(loop = (width * 4); (loop != 0); loop -= 4) |
| 142 | { |
| 143 | CHAROUT(hextab[(uval >> (loop - 4)) & 0xF]); |
| 144 | len++; |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | break; |
| 149 | |
| 150 | case 'd': |
| 151 | /* decimal */ |
| 152 | ival = va_arg(args, int); |
| 153 | |
| 154 | if (ival < 0) |
| 155 | { |
| 156 | ival = -ival; |
| 157 | CHAROUT('-'); |
| 158 | len++; |
| 159 | } |
| 160 | |
| 161 | if (ival == 0) |
| 162 | { |
| 163 | CHAROUT('0'); |
| 164 | len++; |
| 165 | } |
| 166 | else |
| 167 | { |
| 168 | /* |
| 169 | * The simplest method of displaying numbers is |
| 170 | * to provide a small recursive routine, that |
| 171 | * nests until the most-significant digit is |
| 172 | * reached, and then falls back out displaying |
| 173 | * individual digits. However, we want to avoid |
| 174 | * using recursive code within the lo-level |
| 175 | * parts of Angel (to minimise the stack |
| 176 | * usage). The following number conversion is a |
| 177 | * non-recursive solution. |
| 178 | */ |
| 179 | char buffer[16]; /* stack space used to hold number */ |
| 180 | int count = 0; /* pointer into buffer */ |
| 181 | |
| 182 | /* |
| 183 | * Place the conversion into the buffer in |
| 184 | * reverse order: |
| 185 | */ |
| 186 | while (ival != 0) |
| 187 | { |
| 188 | buffer[count++] = ('0' + ((unsigned int)ival % 10)); |
| 189 | ival = ((unsigned int)ival / 10); |
| 190 | } |
| 191 | |
| 192 | /* |
| 193 | * Check if we are placing the data in a |
| 194 | * fixed width field: |
| 195 | */ |
| 196 | if (width != 0) |
| 197 | { |
| 198 | width -= count; |
| 199 | |
| 200 | for (; (width != 0); width--) |
| 201 | { |
| 202 | CHAROUT(padzero ? '0': ' '); |
| 203 | len++; |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | /* then display the buffer in reverse order */ |
| 208 | for (; (count != 0); count--) |
| 209 | { |
| 210 | CHAROUT(buffer[count - 1]); |
| 211 | len++; |
| 212 | } |
| 213 | } |
| 214 | |
| 215 | break; |
| 216 | |
| 217 | case 's': |
| 218 | /* string */ |
| 219 | string = va_arg(args, char *); |
| 220 | |
| 221 | /* we only need this test once */ |
| 222 | if (string != NULL) |
| 223 | /* whilst we check this for every character */ |
| 224 | while (*string) |
| 225 | { |
| 226 | CHAROUT(*string); |
| 227 | len++; |
| 228 | string++; |
| 229 | |
| 230 | /* |
| 231 | * NOTE: We do not use "*string++" as the macro |
| 232 | * parameter, since we do not know how many times |
| 233 | *the parameter may be expanded within the macro. |
| 234 | */ |
| 235 | } |
| 236 | |
| 237 | break; |
| 238 | |
| 239 | case '\0': |
| 240 | /* |
| 241 | * string terminated by '%' character, bodge things |
| 242 | * to prepare for default "format++" below |
| 243 | */ |
| 244 | format--; |
| 245 | |
| 246 | break; |
| 247 | |
| 248 | default: |
| 249 | /* just display the character */ |
| 250 | CHAROUT(*format); |
| 251 | len++; |
| 252 | |
| 253 | break; |
| 254 | } |
| 255 | |
| 256 | format++; /* step over format character */ |
| 257 | } |
| 258 | else |
| 259 | { |
| 260 | CHAROUT(*format); |
| 261 | len++; |
| 262 | format++; |
| 263 | } |
| 264 | } |
| 265 | return len; |
| 266 | } |
| 267 | |
| 268 | /* |
| 269 | * this routine is simply here as a good breakpoint for dumping msg - |
| 270 | * can be used by DEBUG_METHOD macros or functions, if required. |
| 271 | */ |
| 272 | # ifdef DEBUG_NEED_VA_WARN1 |
| 273 | static void va_warn1(int len, char *msg) |
| 274 | { |
| 275 | UNUSED(len); UNUSED(msg); |
| 276 | } |
| 277 | # endif |
| 278 | |
| 279 | void va_warn(WarnLevel level, char *format, va_list args) |
| 280 | { |
| 281 | int len; |
| 282 | |
| 283 | if ( PRE_DEBUG( level ) ) |
| 284 | { |
| 285 | len = va_warn0(format, args); |
| 286 | POST_DEBUG( len ); |
| 287 | } |
| 288 | } |
| 289 | |
| 290 | #else /* ndef DEBUG */ |
| 291 | |
| 292 | void va_warn(WarnLevel level, char *format, va_list args) |
| 293 | { |
| 294 | UNUSED(level); UNUSED(format); UNUSED(args); |
| 295 | } |
| 296 | |
| 297 | #endif /* ... else ndef(DEBUG) ... */ |
| 298 | #pragma check_stack |
| 299 | |
| 300 | #pragma no_check_stack |
| 301 | void __rt_warning(char *format, ...) |
| 302 | { |
| 303 | va_list args; |
| 304 | |
| 305 | /* |
| 306 | * For a multi-threaded system we should provide a lock at this point |
| 307 | * to ensure that the warning messages are sequenced properly. |
| 308 | */ |
| 309 | |
| 310 | va_start(args, format); |
| 311 | va_warn(WL_WARN, format, args); |
| 312 | va_end(args); |
| 313 | |
| 314 | return; |
| 315 | } |
| 316 | #pragma check_stack |
| 317 | |
| 318 | #ifdef TARGET |
| 319 | |
| 320 | #pragma no_check_stack |
| 321 | void __rt_uninterruptable_loop( void ); /* in suppasm.s */ |
| 322 | |
| 323 | void __rt_error(char *format, ...) |
| 324 | { |
| 325 | va_list args; |
| 326 | |
| 327 | va_start(args, format); |
| 328 | |
| 329 | /* Display warning message */ |
| 330 | va_warn(WL_ERROR, format, args); |
| 331 | |
| 332 | __rt_uninterruptable_loop(); |
| 333 | |
| 334 | va_end(args); |
| 335 | return; |
| 336 | } |
| 337 | #pragma check_stack |
| 338 | |
| 339 | #endif /* def TARGET */ |
| 340 | |
| 341 | #ifdef DO_TRACE |
| 342 | |
| 343 | static bool trace_on = FALSE; /* must be set true in debugger if req'd */ |
| 344 | |
| 345 | #pragma no_check_stack |
| 346 | void __rt_trace(char *format, ...) |
| 347 | { |
| 348 | va_list args; |
| 349 | |
| 350 | /* |
| 351 | * For a multi-threaded system we should provide a lock at this point |
| 352 | * to ensure that the warning messages are sequenced properly. |
| 353 | */ |
| 354 | |
| 355 | if (trace_on) |
| 356 | { |
| 357 | va_start(args, format); |
| 358 | va_warn(WL_TRACE, format, args); |
| 359 | va_end(args); |
| 360 | } |
| 361 | |
| 362 | return; |
| 363 | } |
| 364 | #pragma check_stack |
| 365 | |
| 366 | #endif /* def DO_TRACE */ |
| 367 | |
| 368 | |
| 369 | /* EOF logging.c */ |