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 struct nir_shader; 45 46 /* 47 * Low level dumping controls. 48 * 49 * Opening the trace file and checking if that is opened. 50 */ 51 bool trace_dump_trace_begin(void); 52 bool trace_dump_trace_enabled(void); 53 void trace_dump_trace_flush(void); 54 55 /* 56 * Lock and unlock the call mutex. 57 * 58 * It used by the none locked version of dumping control 59 * and begin/end call dump functions. 60 * 61 * Begin takes the lock while end unlocks it. Use the _locked 62 * version to avoid locking/unlocking it. 63 */ 64 void trace_dump_call_lock(void); 65 void trace_dump_call_unlock(void); 66 67 /* 68 * High level dumping control. 69 */ 70 void trace_dumping_start_locked(void); 71 void trace_dumping_stop_locked(void); 72 bool trace_dumping_enabled_locked(void); 73 void trace_dumping_start(void); 74 void trace_dumping_stop(void); 75 bool trace_dumping_enabled(void); 76 77 void trace_dump_call_begin_locked(const char *klass, const char *method); 78 void trace_dump_call_end_locked(void); 79 void trace_dump_call_begin(const char *klass, const char *method); 80 void trace_dump_call_end(void); 81 82 void trace_dump_arg_begin(const char *name); 83 void trace_dump_arg_end(void); 84 void trace_dump_ret_begin(void); 85 void trace_dump_ret_end(void); 86 void trace_dump_bool(bool value); 87 void trace_dump_int(int64_t value); 88 void trace_dump_uint(uint64_t value); 89 void trace_dump_float(double value); 90 void trace_dump_bytes(const void *data, size_t size); 91 void trace_dump_box_bytes(const void *data, 92 struct pipe_resource *resource, 93 const struct pipe_box *box, 94 unsigned stride, 95 uint64_t slice_stride); 96 void trace_dump_string(const char *str); 97 void trace_dump_enum(const char *value); 98 void trace_dump_array_begin(void); 99 void trace_dump_array_end(void); 100 void trace_dump_elem_begin(void); 101 void trace_dump_elem_end(void); 102 void trace_dump_struct_begin(const char *name); 103 void trace_dump_struct_end(void); 104 void trace_dump_member_begin(const char *name); 105 void trace_dump_member_end(void); 106 void trace_dump_null(void); 107 void trace_dump_ptr(const void *value); 108 /* will turn a wrapped object into the real one and dump ptr */ 109 void trace_dump_surface_ptr(struct pipe_surface *_surface); 110 void trace_dump_transfer_ptr(struct pipe_transfer *_transfer); 111 void trace_dump_nir(struct nir_shader *nir); 112 113 void trace_dump_trigger_active(bool active); 114 void trace_dump_check_trigger(void); 115 bool trace_dump_is_triggered(void); 116 117 /* 118 * Code saving macros. 119 */ 120 121 #define trace_dump_arg(_type, _arg) \ 122 do { \ 123 trace_dump_arg_begin(#_arg); \ 124 trace_dump_##_type(_arg); \ 125 trace_dump_arg_end(); \ 126 } while(0) 127 128 #define trace_dump_arg_enum(_type, _arg) \ 129 do { \ 130 trace_dump_arg_begin(#_arg); \ 131 trace_dump_enum(tr_util_##_type##_name(_arg)); \ 132 trace_dump_arg_end(); \ 133 } while(0) 134 135 #define trace_dump_arg_struct(_type, _arg) \ 136 do { \ 137 trace_dump_arg_begin(#_arg); \ 138 trace_dump_##_type(&_arg); \ 139 trace_dump_arg_end(); \ 140 } while(0) 141 142 #define trace_dump_ret(_type, _arg) \ 143 do { \ 144 trace_dump_ret_begin(); \ 145 trace_dump_##_type(_arg); \ 146 trace_dump_ret_end(); \ 147 } while(0) 148 149 #define trace_dump_array_impl(_type, _obj, _size, _prefix) \ 150 do { \ 151 if (_obj) { \ 152 size_t idx; \ 153 trace_dump_array_begin(); \ 154 for(idx = 0; idx < (_size); ++idx) { \ 155 trace_dump_elem_begin(); \ 156 trace_dump_##_type(_prefix(_obj)[idx]); \ 157 trace_dump_elem_end(); \ 158 } \ 159 trace_dump_array_end(); \ 160 } else { \ 161 trace_dump_null(); \ 162 } \ 163 } while(0) 164 165 #define trace_dump_array(_type, _obj, _size) \ 166 trace_dump_array_impl(_type, _obj, _size, ); 167 168 #define trace_dump_array_val(_type, _obj, _size) \ 169 trace_dump_array_impl(_type, _obj, _size, *); 170 171 #define trace_dump_struct_array(_type, _obj, _size) \ 172 do { \ 173 if (_obj) { \ 174 size_t idx; \ 175 trace_dump_array_begin(); \ 176 for(idx = 0; idx < (_size); ++idx) { \ 177 trace_dump_elem_begin(); \ 178 trace_dump_##_type(&(_obj)[idx]); \ 179 trace_dump_elem_end(); \ 180 } \ 181 trace_dump_array_end(); \ 182 } else { \ 183 trace_dump_null(); \ 184 } \ 185 } while(0) 186 187 #define trace_dump_member(_type, _obj, _member) \ 188 do { \ 189 trace_dump_member_begin(#_member); \ 190 trace_dump_##_type((_obj)->_member); \ 191 trace_dump_member_end(); \ 192 } while(0) 193 194 195 #define trace_dump_member_enum(_type, _obj, _member) \ 196 do { \ 197 trace_dump_member_begin(#_member); \ 198 trace_dump_enum(tr_util_##_type##_name((_obj)->_member)); \ 199 trace_dump_member_end(); \ 200 } while(0) 201 202 #define trace_dump_member_struct(_type, _obj, _member) \ 203 do { \ 204 trace_dump_member_begin(#_member); \ 205 trace_dump_##_type(&((_obj)->_member)); \ 206 trace_dump_member_end(); \ 207 } while(0) 208 209 #define trace_dump_arg_array(_type, _arg, _size) \ 210 do { \ 211 trace_dump_arg_begin(#_arg); \ 212 trace_dump_array(_type, _arg, _size); \ 213 trace_dump_arg_end(); \ 214 } while(0) 215 216 #define trace_dump_arg_array_val(_type, _arg, _size) \ 217 do { \ 218 trace_dump_arg_begin(#_arg); \ 219 trace_dump_array_val(_type, _arg, _size); \ 220 trace_dump_arg_end(); \ 221 } while(0) 222 223 #define trace_dump_ret_array(_type, _arg, _size) \ 224 do { \ 225 trace_dump_ret_begin(); \ 226 trace_dump_array(_type, _arg, _size); \ 227 trace_dump_ret_end(); \ 228 } while(0) 229 230 #define trace_dump_ret_array_val(_type, _arg, _size) \ 231 do { \ 232 trace_dump_ret_begin(); \ 233 trace_dump_array_val(_type, _arg, _size); \ 234 trace_dump_ret_end(); \ 235 } while(0) 236 237 #define trace_dump_member_array(_type, _obj, _member) \ 238 do { \ 239 trace_dump_member_begin(#_member); \ 240 trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 241 trace_dump_member_end(); \ 242 } while(0) 243 244 245 #endif /* TR_DUMP_H */ 246