~thopiekar/arm-mali/libump-sunxi

« back to all changes in this revision

Viewing changes to src/ump_debug.h

  • Committer: Luc Verhaegen
  • Date: 2014-03-25 21:04:12 UTC
  • Revision ID: git-v1:fa5ad94ac2873793dcca65dafc3ea211de5e7226
import ump r2p4 source

Signed-off-by: Luc Verhaegen <libv@skynet.be>

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * Copyright (C) 2010-2012 ARM Limited. All rights reserved.
 
3
 * 
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 * 
 
8
 *       http://www.apache.org/licenses/LICENSE-2.0
 
9
 * 
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
/**
 
18
 * @file ump_debug.h
 
19
 *
 
20
 * The file include several useful macros for debugging and printing.
 
21
 * - UMP_PRINTF(...)           Do not use this function: Will be included in Release builds.
 
22
 * - UMP_DEBUG_TRACE()         Prints current location in code.
 
23
 * - UMP_DEBUG_PRINT(nr, (X) ) Prints the second argument if nr<=UMP_DEBUG_LEVEL.
 
24
 * - UMP_DEBUG_TPRINT(nr, X )  Prints the source trace and second argument if nr<=UMP_DEBUG_LEVEL.
 
25
 * - UMP_DEBUG_ERROR( (X) )    Prints an errortext, a source trace, and the given error message.
 
26
 * - UMP_DEBUG_ASSERT(exp,(X)) If the asserted expr is false, the program will exit.
 
27
 * - UMP_DEBUG_ASSERT_RANGE(x, min, max) Triggers if variable x is not between or equal to max and min.
 
28
 * - UMP_DEBUG_ASSERT_LEQ(x, max) Triggers if variable x is not less than equal to max.
 
29
 * - UMP_DEBUG_ASSERT_POINTER(pointer)  Triggers if the pointer is a zero pointer.
 
30
 * - UMP_DEBUG_CODE( X )       The code inside the macro is only copiled in Debug builds.
 
31
 *
 
32
 * The (X) means that you must add an extra parantese around the argumentlist.
 
33
 *
 
34
 * The  printf function: UMP_PRINTF(...) is routed to _ump_sys_printf
 
35
 *
 
36
 * Suggested range for the DEBUG-LEVEL is [1:6] where
 
37
 * [1:2] Is messages with highest priority, indicate possible errors.
 
38
 * [3:4] Is messages with medium priority, output important variables.
 
39
 * [5:6] Is messages with low priority, used during extensive debugging.
 
40
 *
 
41
 */
 
42
#ifndef _UMP_DEBUG_H_
 
43
#define _UMP_DEBUG_H_
 
44
 
 
45
#include <stdio.h>
 
46
#include <stdlib.h>
 
47
 
 
48
/* START: Configuration */
 
49
#ifndef UMP_PRINTF
 
50
        #define UMP_PRINTF printf
 
51
#endif /* UMP_PRINTF */
 
52
 
 
53
#ifndef UMP_PRINT_FLUSH
 
54
        #define UMP_PRINT_FLUSH do {} while (0)
 
55
#endif /* UMP_PRINT_FLUSH */
 
56
 
 
57
#ifndef UMP_DEBUG_LEVEL
 
58
    #define UMP_DEBUG_LEVEL 1
 
59
#endif /* UMP_DEBUG_LEVEL */
 
60
 
 
61
#ifndef UMP_DEBUG_ERROR_START_MSG
 
62
    #define UMP_DEBUG_ERROR_START_MSG do {\
 
63
    UMP_PRINTF("*********************************************************************\n");\
 
64
    UMP_PRINT_FLUSH; } while (0)
 
65
#endif /* UMP_DEBUG_ERROR_START_MSG */
 
66
 
 
67
#ifndef UMP_DEBUG_ERROR_STOP_MSG
 
68
    #define UMP_DEBUG_ERROR_STOP_MSG  do { UMP_PRINTF("\n"); UMP_PRINT_FLUSH; } while (0)
 
69
#endif /* UMP_DEBUG_ERROR_STOP_MSG */
 
70
 
 
71
#ifndef UMP_ASSERT_QUIT_CMD
 
72
        #define UMP_ASSERT_QUIT_CMD    abort()
 
73
#endif /* UMP_ASSERT_QUIT_CMD */
 
74
/* STOP: Configuration */
 
75
 
 
76
/**
 
77
 *      The macro UMP_FUNCTION evaluates to the name of the function enclosing
 
78
 *      this macro's usage, or "<unknown>" if not supported.
 
79
 */
 
80
#if (defined(__SYMBIAN32__) && defined(__ARMCC__)) || defined(_MSC_VER)
 
81
#       define UMP_FUNCTION __FUNCTION__
 
82
#elif __STDC__  && __STDC_VERSION__ >= 199901L
 
83
#       define UMP_FUNCTION __FUNCTION__
 
84
#elif defined(__GNUC__) && __GNUC__ >= 2
 
85
#       define UMP_FUNCTION __FUNCTION__
 
86
#elif defined(__func__)
 
87
#       define UMP_FUNCTION __func__
 
88
#else
 
89
#       define UMP_FUNCTION "<unknown>"
 
90
#endif
 
91
 
 
92
/**
 
93
 *      Explicitly ignore a parameter passed into a function, to suppress compiler warnings.
 
94
 *      Should only be used with parameter names.
 
95
 */
 
96
#define UMP_IGNORE(x) (void)x
 
97
 
 
98
/**
 
99
 * @def     UMP_DEBUG_TRACE()
 
100
 * @brief   Prints current location in code.
 
101
 *          Can be turned off by defining UMP_DEBUG_SKIP_TRACE
 
102
 */
 
103
 
 
104
#ifndef UMP_DEBUG_SKIP_TRACE
 
105
    #ifndef UMP_DEBUG_SKIP_PRINT_FUNCTION_NAME
 
106
        #define UMP_DEBUG_TRACE()  do { UMP_PRINTF( "In file: "__FILE__ \
 
107
                        "  function: %s()   line:%4d\n" , UMP_FUNCTION, __LINE__);  UMP_PRINT_FLUSH; } while (0)
 
108
        #else
 
109
        #define UMP_DEBUG_TRACE()  do { UMP_PRINTF( "In file: "__FILE__ "  line:%4d\n" , __LINE__);  UMP_PRINT_FLUSH; } while (0)
 
110
        #endif /* UMP_DEBUG_SKIP_PRINT_FUNCTION_NAME */
 
111
#else
 
112
    #define UMP_DEBUG_TRACE()
 
113
#endif /* UMP_DEBUG_SKIP_TRACE */
 
114
 
 
115
/**
 
116
 * @def     UMP_DEBUG_PRINT(nr, (X) )
 
117
 * @brief   Prints the second argument if nr<=UMP_DEBUG_LEVEL.
 
118
 *          Can be turned off by defining UMP_DEBUG_SKIP_PRINT
 
119
 * @param   nr   If nr <= UMP_DEBUG_LEVEL, we print the text.
 
120
 * @param   X  A parantese with the contents to be sent to UMP_PRINTF
 
121
 */
 
122
#ifndef UMP_DEBUG_SKIP_PRINT
 
123
    #define UMP_DEBUG_PRINT(nr, X )  do { if ( nr<=UMP_DEBUG_LEVEL ) { UMP_PRINTF X ; UMP_PRINT_FLUSH; } } while (0)
 
124
#else
 
125
    #define UMP_DEBUG_PRINT(nr, X )
 
126
#endif /* UMP_DEBUG_SKIP_PRINT */
 
127
 
 
128
/**
 
129
 * @def     UMP_DEBUG_TPRINT(nr, (X) )
 
130
 * @brief   Prints the second argument if nr<=UMP_DEBUG_LEVEL.
 
131
 *          Can be turned off by defining UMP_DEBUG_SKIP_TPRINT.
 
132
 *          Can be shortened by defining UMP_DEBUG_TPRINT_SKIP_FUNCTION.
 
133
 * @param   nr   If nr <= UMP_DEBUG_LEVEL, we print the text.
 
134
 * @param   X  A parantese with the contents to be sent to UMP_PRINTF
 
135
 */
 
136
 
 
137
/* helper to handle if the function name should be included or not */
 
138
#ifndef UMP_DEBUG_TPRINT_SKIP_FUNCTION
 
139
    #define UMP_DEBUG_TPRINT_INTERN do {UMP_PRINTF( ""__FILE__" %s()%4d " , UMP_FUNCTION, __LINE__); UMP_PRINT_FLUSH; }  while (0)
 
140
#else
 
141
    #define UMP_DEBUG_TPRINT_INTERN do {UMP_PRINTF( ""__FILE__ "%4d " , __LINE__); UMP_PRINT_FLUSH; }  while (0)
 
142
#endif /* UMP_DEBUG_TPRINT_SKIP_FUNCTION */
 
143
 
 
144
#ifndef UMP_DEBUG_SKIP_TPRINT
 
145
        #define UMP_DEBUG_TPRINT(nr, X ) \
 
146
    do{\
 
147
        if ( nr<=UMP_DEBUG_LEVEL )\
 
148
        {\
 
149
            UMP_DEBUG_TPRINT_INTERN;\
 
150
            UMP_PRINTF X ;\
 
151
            UMP_PRINT_FLUSH;\
 
152
        }\
 
153
    } while (0)
 
154
#else
 
155
    #define UMP_DEBUG_TPRINT(nr, X )
 
156
#endif /* UMP_DEBUG_SKIP_TPRINT */
 
157
 
 
158
/**
 
159
 * @def     UMP_DEBUG_ERROR( (X) )
 
160
 * @brief   Prints an errortext, a source Trace, and the given error message.
 
161
 *          Prints filename, function, linenr, and the given error message.
 
162
 *          The error message must be inside a second parantese.
 
163
 *          The error message is written on a separate line, and a NL char is added.
 
164
 *          Can be turned of by defining UMP_DEBUG_SKIP_ERROR;
 
165
 *          You do not need to type the words ERROR in the message, since it will
 
166
 *          be added anyway.
 
167
 *
 
168
 * @note    You should not end the text with a newline, since it is added by the macro.
 
169
 * @note    You should not write "ERROR" in the text, since it is added by the macro.
 
170
 * @param    X  A parantese with the contents to be sent to UMP_PRINTF
 
171
 */
 
172
 
 
173
#ifndef UMP_DEBUG_SKIP_ERROR
 
174
    #define UMP_DEBUG_ERROR( X )  \
 
175
        do{ \
 
176
            UMP_DEBUG_ERROR_START_MSG;\
 
177
            UMP_PRINTF("ERROR: ");\
 
178
            UMP_PRINT_FLUSH;\
 
179
            UMP_DEBUG_TRACE(); \
 
180
            UMP_PRINTF X ; \
 
181
            UMP_PRINT_FLUSH;\
 
182
            UMP_DEBUG_ERROR_STOP_MSG;\
 
183
        } while (0)
 
184
#else
 
185
    #define UMP_DEBUG_ERROR( X ) do{ ; } while ( 0 )
 
186
#endif /* UMP_DEBUG_SKIP_ERROR */
 
187
 
 
188
/**
 
189
 * @def     UMP_DEBUG_ASSERT(expr, (X) )
 
190
 * @brief   If the asserted expr is false, the program will exit.
 
191
 *          Prints filename, function, linenr, and the given error message.
 
192
 *          The error message must be inside a second parantese.
 
193
 *          The error message is written on a separate line, and a NL char is added.
 
194
 *          Can be turned of by defining UMP_DEBUG_SKIP_ERROR;
 
195
 *          You do not need to type the words ASSERT in the message, since it will
 
196
 *          be added anyway.
 
197
 *
 
198
 * @param    X  A parantese with the contents to be sent to UMP_PRINTF
 
199
 *          Prints filename, function, linenr, and the error message
 
200
 *          on a separte line. A newline char is added at the end.
 
201
 *          Can be turned of by defining UMP_DEBUG_SKIP_ASSERT
 
202
 * @param   expr  Will exit program if \a expr is false;
 
203
 * @param   (X)  Text that will be written if the assertion toggles.
 
204
 */
 
205
 
 
206
#ifndef UMP_DEBUG_SKIP_ASSERT
 
207
    #define UMP_DEBUG_ASSERT(expr, X ) \
 
208
    do{\
 
209
        if ( !(expr) ) \
 
210
        { \
 
211
                UMP_DEBUG_ERROR_START_MSG;\
 
212
                UMP_PRINTF("ASSERT EXIT: ");\
 
213
                UMP_PRINT_FLUSH;\
 
214
                UMP_DEBUG_TRACE(); \
 
215
                UMP_PRINTF X ; \
 
216
                UMP_PRINT_FLUSH;\
 
217
                UMP_DEBUG_ERROR_STOP_MSG;\
 
218
                UMP_ASSERT_QUIT_CMD;\
 
219
        }\
 
220
    } while (0)
 
221
#else
 
222
        #define UMP_DEBUG_ASSERT(expr, X)
 
223
#endif /* UMP_DEBUG_SKIP_ASSERT */
 
224
 
 
225
 
 
226
/**
 
227
 * @def     UMP_DEBUG_ASSERT_POINTER(pointer)
 
228
 * @brief   If the asserted pointer is NULL, the program terminates and TRACE info is printed
 
229
 *          The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
 
230
 */
 
231
#define UMP_DEBUG_ASSERT_POINTER(pointer) UMP_DEBUG_ASSERT(pointer, ("Null pointer " #pointer) )
 
232
 
 
233
/**
 
234
 * @def     UMP_DEBUG_ASSERT_HANDLE(handle)
 
235
 * @brief   If the asserted handle is not a valid handle, the program terminates and TRACE info is printed
 
236
 *          The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
 
237
 */
 
238
#define UMP_DEBUG_ASSERT_HANDLE(handle) UMP_DEBUG_ASSERT(UMP_NO_HANDLE != (handle), ("Invalid handle" #handle) )
 
239
 
 
240
/**
 
241
 * @def     UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align)
 
242
 * @brief   If the asserted pointer is  not aligned to align, the program terminates with trace info printed.
 
243
 *          The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
 
244
 */
 
245
#ifndef UMP_DEBUG_SKIP_ASSERT
 
246
        #define UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align) do {                                                    \
 
247
                UMP_DEBUG_ASSERT(0 == (align & (align - 1)), ("align %d is not a power-of-two", align));           \
 
248
                UMP_DEBUG_ASSERT(0 == (((u32)(ptr)) & (align - 1)), ("ptr %p not aligned to %d bytes", (void*)ptr, align)); \
 
249
                } while (0)
 
250
#else
 
251
        #define UMP_DEBUG_ASSERT_ALIGNMENT(ptr, align)
 
252
#endif /* UMP_DEBUG_SKIP_ASSERT */
 
253
 
 
254
/**
 
255
 * @def     UMP_DEBUG_ASSERT_RANGE(x,min,max)
 
256
 * @brief   If variable x is not between or equal to max and min, the assertion triggers.
 
257
 *          The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
 
258
 */
 
259
#define UMP_DEBUG_ASSERT_RANGE(x, min, max) \
 
260
        UMP_DEBUG_ASSERT( (x) >= (min) && (x) <= (max), \
 
261
                           (#x " out of range (%2.2f)", (double)x ) \
 
262
                         )
 
263
 
 
264
/**
 
265
 * @def     UMP_DEBUG_ASSERT_LEQ(x,max)
 
266
 * @brief   If variable x is less than or equal to max, the assertion triggers.
 
267
 *          The checking is disabled if "UMP_DEBUG_SKIP_ASSERT" is defined.
 
268
 */
 
269
#define UMP_DEBUG_ASSERT_LEQ(x, max) \
 
270
        UMP_DEBUG_ASSERT( (x) <= (max), \
 
271
                           (#x " out of range (%2.2f)", (double)x ) \
 
272
                         )
 
273
 
 
274
/**
 
275
 * @def     UMP_DEBUG_CODE( X )
 
276
 * @brief   Run the code X on debug builds.
 
277
 *          The code will not be used if UMP_DEBUG_SKIP_CODE is defined .
 
278
 *
 
279
 */
 
280
#ifdef UMP_DEBUG_SKIP_CODE
 
281
    #define UMP_DEBUG_CODE( X )
 
282
#else
 
283
    #define UMP_DEBUG_CODE( X ) X
 
284
#endif /* UMP_DEBUG_SKIP_CODE */
 
285
 
 
286
#endif /* _UMP_DEBUG_H_ */
 
287