1 /************************************************************************** 2 * 3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 /** 29 * @file 30 * Trace data dumping primitives. 31 */ 32 33 #ifndef TR_DUMP_H 34 #define TR_DUMP_H 35 36 37 #include "pipe/p_compiler.h" 38 #include "pipe/p_format.h" 39 40 struct pipe_resource; 41 struct pipe_surface; 42 struct pipe_transfer; 43 struct pipe_box; 44 45 /* 46 * Low level dumping controls. 47 * 48 * Opening the trace file and checking if that is opened. 49 */ 50 boolean trace_dump_trace_begin(void); 51 boolean trace_dump_trace_enabled(void); 52 void trace_dump_trace_end(void); 53 54 /* 55 * Lock and unlock the call mutex. 56 * 57 * It used by the none locked version of dumping control 58 * and begin/end call dump functions. 59 * 60 * Begin takes the lock while end unlocks it. Use the _locked 61 * version to avoid locking/unlocking it. 62 */ 63 void trace_dump_call_lock(void); 64 void trace_dump_call_unlock(void); 65 66 /* 67 * High level dumping control. 68 */ 69 void trace_dumping_start_locked(void); 70 void trace_dumping_stop_locked(void); 71 boolean trace_dumping_enabled_locked(void); 72 void trace_dumping_start(void); 73 void trace_dumping_stop(void); 74 boolean trace_dumping_enabled(void); 75 76 void trace_dump_call_begin_locked(const char *klass, const char *method); 77 void trace_dump_call_end_locked(void); 78 void trace_dump_call_begin(const char *klass, const char *method); 79 void trace_dump_call_end(void); 80 81 void trace_dump_arg_begin(const char *name); 82 void trace_dump_arg_end(void); 83 void trace_dump_ret_begin(void); 84 void trace_dump_ret_end(void); 85 void trace_dump_bool(int value); 86 void trace_dump_int(long long int value); 87 void trace_dump_uint(long long unsigned value); 88 void trace_dump_float(double value); 89 void trace_dump_bytes(const void *data, size_t size); 90 void trace_dump_box_bytes(const void *data, 91 enum pipe_format format, 92 const struct pipe_box *box, 93 unsigned stride, 94 unsigned slice_stride); 95 void trace_dump_string(const char *str); 96 void trace_dump_enum(const char *value); 97 void trace_dump_array_begin(void); 98 void trace_dump_array_end(void); 99 void trace_dump_elem_begin(void); 100 void trace_dump_elem_end(void); 101 void trace_dump_struct_begin(const char *name); 102 void trace_dump_struct_end(void); 103 void trace_dump_member_begin(const char *name); 104 void trace_dump_member_end(void); 105 void trace_dump_null(void); 106 void trace_dump_ptr(const void *value); 107 /* will turn a wrapped object into the real one and dump ptr */ 108 void trace_dump_resource_ptr(struct pipe_resource *_texture); 109 void trace_dump_surface_ptr(struct pipe_surface *_surface); 110 void trace_dump_transfer_ptr(struct pipe_transfer *_transfer); 111 112 /* 113 * Code saving macros. 114 */ 115 116 #define trace_dump_arg(_type, _arg) \ 117 do { \ 118 trace_dump_arg_begin(#_arg); \ 119 trace_dump_##_type(_arg); \ 120 trace_dump_arg_end(); \ 121 } while(0) 122 123 #define trace_dump_arg_struct(_type, _arg) \ 124 do { \ 125 trace_dump_arg_begin(#_arg); \ 126 trace_dump_##_type(&_arg); \ 127 trace_dump_arg_end(); \ 128 } while(0) 129 130 #define trace_dump_ret(_type, _arg) \ 131 do { \ 132 trace_dump_ret_begin(); \ 133 trace_dump_##_type(_arg); \ 134 trace_dump_ret_end(); \ 135 } while(0) 136 137 #define trace_dump_array(_type, _obj, _size) \ 138 do { \ 139 size_t idx; \ 140 trace_dump_array_begin(); \ 141 for(idx = 0; idx < (_size); ++idx) { \ 142 trace_dump_elem_begin(); \ 143 trace_dump_##_type((_obj)[idx]); \ 144 trace_dump_elem_end(); \ 145 } \ 146 trace_dump_array_end(); \ 147 } while(0) 148 149 #define trace_dump_struct_array(_type, _obj, _size) \ 150 do { \ 151 size_t idx; \ 152 trace_dump_array_begin(); \ 153 for(idx = 0; idx < (_size); ++idx) { \ 154 trace_dump_elem_begin(); \ 155 trace_dump_##_type(&(_obj)[idx]); \ 156 trace_dump_elem_end(); \ 157 } \ 158 trace_dump_array_end(); \ 159 } while(0) 160 161 #define trace_dump_member(_type, _obj, _member) \ 162 do { \ 163 trace_dump_member_begin(#_member); \ 164 trace_dump_##_type((_obj)->_member); \ 165 trace_dump_member_end(); \ 166 } while(0) 167 168 #define trace_dump_arg_array(_type, _arg, _size) \ 169 do { \ 170 trace_dump_arg_begin(#_arg); \ 171 trace_dump_array(_type, _arg, _size); \ 172 trace_dump_arg_end(); \ 173 } while(0) 174 175 #define trace_dump_member_array(_type, _obj, _member) \ 176 do { \ 177 trace_dump_member_begin(#_member); \ 178 trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 179 trace_dump_member_end(); \ 180 } while(0) 181 182 183 #endif /* TR_DUMP_H */ 184