1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 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 VMWARE 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 "util/compiler.h" 38 #include "util/format/u_formats.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 bool trace_dump_trace_begin(void); 51 bool trace_dump_trace_enabled(void); 52 void trace_dump_trace_flush(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 bool trace_dumping_enabled_locked(void); 72 void trace_dumping_start(void); 73 void trace_dumping_stop(void); 74 bool 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(bool value); 86 void trace_dump_int(int64_t value); 87 void trace_dump_uint(uint64_t 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 struct pipe_resource *resource, 92 const struct pipe_box *box, 93 unsigned stride, 94 uint64_t 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_surface_ptr(struct pipe_surface *_surface); 109 void trace_dump_transfer_ptr(struct pipe_transfer *_transfer); 110 void trace_dump_nir(void *nir); 111 112 void trace_dump_trigger_active(bool active); 113 void trace_dump_check_trigger(void); 114 bool trace_dump_is_triggered(void); 115 116 /* 117 * Code saving macros. 118 */ 119 120 #define trace_dump_arg(_type, _arg) \ 121 do { \ 122 trace_dump_arg_begin(#_arg); \ 123 trace_dump_##_type(_arg); \ 124 trace_dump_arg_end(); \ 125 } while(0) 126 127 #define trace_dump_arg_enum(_type, _arg) \ 128 do { \ 129 trace_dump_arg_begin(#_arg); \ 130 trace_dump_enum(tr_util_##_type##_name(_arg)); \ 131 trace_dump_arg_end(); \ 132 } while(0) 133 134 #define trace_dump_arg_struct(_type, _arg) \ 135 do { \ 136 trace_dump_arg_begin(#_arg); \ 137 trace_dump_##_type(&_arg); \ 138 trace_dump_arg_end(); \ 139 } while(0) 140 141 #define trace_dump_ret(_type, _arg) \ 142 do { \ 143 trace_dump_ret_begin(); \ 144 trace_dump_##_type(_arg); \ 145 trace_dump_ret_end(); \ 146 } while(0) 147 148 #define trace_dump_array_impl(_type, _obj, _size, _prefix) \ 149 do { \ 150 if (_obj) { \ 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(_prefix(_obj)[idx]); \ 156 trace_dump_elem_end(); \ 157 } \ 158 trace_dump_array_end(); \ 159 } else { \ 160 trace_dump_null(); \ 161 } \ 162 } while(0) 163 164 #define trace_dump_array(_type, _obj, _size) \ 165 trace_dump_array_impl(_type, _obj, _size, ); 166 167 #define trace_dump_array_val(_type, _obj, _size) \ 168 trace_dump_array_impl(_type, _obj, _size, *); 169 170 #define trace_dump_struct_array(_type, _obj, _size) \ 171 do { \ 172 if (_obj) { \ 173 size_t idx; \ 174 trace_dump_array_begin(); \ 175 for(idx = 0; idx < (_size); ++idx) { \ 176 trace_dump_elem_begin(); \ 177 trace_dump_##_type(&(_obj)[idx]); \ 178 trace_dump_elem_end(); \ 179 } \ 180 trace_dump_array_end(); \ 181 } else { \ 182 trace_dump_null(); \ 183 } \ 184 } while(0) 185 186 #define trace_dump_member(_type, _obj, _member) \ 187 do { \ 188 trace_dump_member_begin(#_member); \ 189 trace_dump_##_type((_obj)->_member); \ 190 trace_dump_member_end(); \ 191 } while(0) 192 193 194 #define trace_dump_member_enum(_type, _obj, _member) \ 195 do { \ 196 trace_dump_member_begin(#_member); \ 197 trace_dump_enum(tr_util_##_type##_name((_obj)->_member)); \ 198 trace_dump_member_end(); \ 199 } while(0) 200 201 #define trace_dump_member_struct(_type, _obj, _member) \ 202 do { \ 203 trace_dump_member_begin(#_member); \ 204 trace_dump_##_type(&((_obj)->_member)); \ 205 trace_dump_member_end(); \ 206 } while(0) 207 208 #define trace_dump_arg_array(_type, _arg, _size) \ 209 do { \ 210 trace_dump_arg_begin(#_arg); \ 211 trace_dump_array(_type, _arg, _size); \ 212 trace_dump_arg_end(); \ 213 } while(0) 214 215 #define trace_dump_arg_array_val(_type, _arg, _size) \ 216 do { \ 217 trace_dump_arg_begin(#_arg); \ 218 trace_dump_array_val(_type, _arg, _size); \ 219 trace_dump_arg_end(); \ 220 } while(0) 221 222 #define trace_dump_ret_array(_type, _arg, _size) \ 223 do { \ 224 trace_dump_ret_begin(); \ 225 trace_dump_array(_type, _arg, _size); \ 226 trace_dump_ret_end(); \ 227 } while(0) 228 229 #define trace_dump_ret_array_val(_type, _arg, _size) \ 230 do { \ 231 trace_dump_ret_begin(); \ 232 trace_dump_array_val(_type, _arg, _size); \ 233 trace_dump_ret_end(); \ 234 } while(0) 235 236 #define trace_dump_member_array(_type, _obj, _member) \ 237 do { \ 238 trace_dump_member_begin(#_member); \ 239 trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 240 trace_dump_member_end(); \ 241 } while(0) 242 243 244 #endif /* TR_DUMP_H */ 245