src/broadcom/clif/clif_dump.c

   1 /*
   2  * Copyright © 2016 Broadcom
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include "clif_dump.h"
  28 #include "util/list.h"
  29 #include "util/ralloc.h"
  30
  31 #include "broadcom/cle/v3d_decoder.h"
  32
  33 #define __gen_user_data void
  34 #define __gen_address_type uint32_t
  35 #define __gen_address_offset(reloc) (*reloc)
  36 #define __gen_emit_reloc(cl, reloc)
  37 #define __gen_unpack_address(cl, s, e) (__gen_unpack_uint(cl, s, e) << (31 - (e - s)))
  38
  39 enum reloc_worklist_type {
  40         reloc_gl_shader_state,
  41 };
  42
  43 struct reloc_worklist_entry {
  44         struct list_head link;
  45
  46         enum reloc_worklist_type type;
  47         uint32_t addr;
  48
  49         union {
  50                 struct {
  51                         uint32_t num_attrs;
  52                 } shader_state;
  53         };
  54 };
  55
  56 struct clif_dump {
  57         const struct v3d_device_info *devinfo;
  58         bool (*lookup_vaddr)(void *data, uint32_t addr, void **vaddr);
  59         FILE *out;
  60         /* Opaque data from the caller that is passed to the callbacks. */
  61         void *data;
  62
  63         struct v3d_spec *spec;
  64
  65         /* List of struct reloc_worklist_entry */
  66         struct list_head worklist;
  67 };
  68
  69 static void
  70 out(struct clif_dump *clif, const char *fmt, ...)
  71 {
  72         va_list args;
  73
  74         va_start(args, fmt);
  75         vfprintf(clif->out, fmt, args);
  76         va_end(args);
  77 }
  78
  79 #include "broadcom/cle/v3d_packet_v33_pack.h"
  80
  81 static struct reloc_worklist_entry *
  82 clif_dump_add_address_to_worklist(struct clif_dump *clif,
  83                                   enum reloc_worklist_type type,
  84                                   uint32_t addr)
  85 {
  86         struct reloc_worklist_entry *entry =
  87                 rzalloc(clif, struct reloc_worklist_entry);
  88         if (!entry)
  89                 return NULL;
  90
  91         entry->type = type;
  92         entry->addr = addr;
  93
  94         list_addtail(&entry->link, &clif->worklist);
  95
  96         return entry;
  97 }
  98
  99 struct clif_dump *
 100 clif_dump_init(const struct v3d_device_info *devinfo,
 101                FILE *out,
 102                bool (*lookup_vaddr)(void *data, uint32_t addr, void **vaddr),
 103                void *data)
 104 {
 105         struct clif_dump *clif = rzalloc(NULL, struct clif_dump);
 106
 107         clif->devinfo = devinfo;
 108         clif->lookup_vaddr = lookup_vaddr;
 109         clif->out = out;
 110         clif->data = data;
 111         clif->spec = v3d_spec_load(devinfo);
 112
 113         list_inithead(&clif->worklist);
 114
 115         return clif;
 116 }
 117
 118 void
 119 clif_dump_destroy(struct clif_dump *clif)
 120 {
 121         ralloc_free(clif);
 122 }
 123
 124 #define out_uint(_clif, field) out(_clif, "    /* %s = */ %u\n",        \
 125                             #field,  values-> field);
 126
 127 static bool
 128 clif_dump_packet(struct clif_dump *clif, uint32_t offset, const uint8_t *cl,
 129                  uint32_t *size)
 130 {
 131         struct v3d_group *inst = v3d_spec_find_instruction(clif->spec, cl);
 132         if (!inst) {
 133                 out(clif, "0x%08x: Unknown packet %d!\n", offset, *cl);
 134                 return false;
 135         }
 136
 137         *size = v3d_group_get_length(inst);
 138
 139         out(clif, "%s\n", v3d_group_get_name(inst));
 140         v3d_print_group(clif->out, inst, 0, cl, "");
 141
 142         switch (*cl) {
 143         case V3D33_GL_SHADER_STATE_opcode: {
 144                 struct V3D33_GL_SHADER_STATE values;
 145                 V3D33_GL_SHADER_STATE_unpack(cl, &values);
 146
 147                 struct reloc_worklist_entry *reloc =
 148                         clif_dump_add_address_to_worklist(clif,
 149                                                           reloc_gl_shader_state,
 150                                                           values.address);
 151                 if (reloc) {
 152                         reloc->shader_state.num_attrs =
 153                                 values.number_of_attribute_arrays;
 154                 }
 155                 return true;
 156         }
 157
 158         case V3D33_STORE_MULTI_SAMPLE_RESOLVED_TILE_COLOR_BUFFER_EXTENDED_opcode: {
 159                 struct V3D33_STORE_MULTI_SAMPLE_RESOLVED_TILE_COLOR_BUFFER_EXTENDED values;
 160                 V3D33_STORE_MULTI_SAMPLE_RESOLVED_TILE_COLOR_BUFFER_EXTENDED_unpack(cl, &values);
 161
 162                 if (values.last_tile_of_frame)
 163                         return false;
 164                 break;
 165         }
 166
 167         case V3D33_TRANSFORM_FEEDBACK_ENABLE_opcode: {
 168                 struct V3D33_TRANSFORM_FEEDBACK_ENABLE values;
 169                 V3D33_TRANSFORM_FEEDBACK_ENABLE_unpack(cl, &values);
 170                 struct v3d_group *spec = v3d_spec_find_struct(clif->spec,
 171                                                               "Transform Feedback Output Data Spec");
 172                 struct v3d_group *addr = v3d_spec_find_struct(clif->spec,
 173                                                               "Transform Feedback Output Address");
 174                 assert(spec);
 175                 assert(addr);
 176
 177                 cl += *size;
 178
 179                 for (int i = 0; i < values.number_of_16_bit_output_data_specs_following; i++) {
 180                         v3d_print_group(clif->out, spec, 0, cl, "");
 181                         cl += v3d_group_get_length(spec);
 182                         *size += v3d_group_get_length(spec);
 183                 }
 184
 185                 for (int i = 0; i < values.number_of_32_bit_output_buffer_address_following; i++) {
 186                         v3d_print_group(clif->out, addr, 0, cl, "");
 187                         cl += v3d_group_get_length(addr);
 188                         *size += v3d_group_get_length(addr);
 189                 }
 190                 break;
 191         }
 192
 193         case V3D33_HALT_opcode:
 194                 return false;
 195         }
 196
 197         return true;
 198 }
 199
 200 static void
 201 clif_dump_gl_shader_state_record(struct clif_dump *clif,
 202                                  struct reloc_worklist_entry *reloc, void *vaddr)
 203 {
 204         struct v3d_group *state = v3d_spec_find_struct(clif->spec,
 205                                                        "GL Shader State Record");
 206         struct v3d_group *attr = v3d_spec_find_struct(clif->spec,
 207                                                       "GL Shader State Attribute Record");
 208         assert(state);
 209         assert(attr);
 210
 211         out(clif, "GL Shader State Record at 0x%08x\n", reloc->addr);
 212         v3d_print_group(clif->out, state, 0, vaddr, "");
 213         vaddr += v3d_group_get_length(state);
 214
 215         for (int i = 0; i < reloc->shader_state.num_attrs; i++) {
 216                 out(clif, "  Attribute %d\n", i);
 217                 v3d_print_group(clif->out, attr, 0, vaddr, "");
 218                 vaddr += v3d_group_get_length(attr);
 219         }
 220 }
 221
 222 static void
 223 clif_process_worklist(struct clif_dump *clif)
 224 {
 225         while (!list_empty(&clif->worklist)) {
 226                 struct reloc_worklist_entry *reloc =
 227                         list_first_entry(&clif->worklist,
 228                                          struct reloc_worklist_entry, link);
 229                 list_del(&reloc->link);
 230
 231                 void *vaddr;
 232                 if (!clif->lookup_vaddr(clif->data, reloc->addr, &vaddr)) {
 233                         out(clif, "Failed to look up address 0x%08x\n",
 234                             reloc->addr);
 235                         continue;
 236                 }
 237
 238                 switch (reloc->type) {
 239                 case reloc_gl_shader_state:
 240                         clif_dump_gl_shader_state_record(clif, reloc, vaddr);
 241                         break;
 242                 }
 243                 out(clif, "\n");
 244         }
 245 }
 246
 247 void
 248 clif_dump_add_cl(struct clif_dump *clif, uint32_t address)
 249 {
 250         uint32_t size;
 251
 252         void *vaddr;
 253         if (!clif->lookup_vaddr(clif->data, address, &vaddr)) {
 254                 out(clif, "Failed to look up address 0x%08x\n",
 255                     address);
 256                 return;
 257         }
 258
 259         uint8_t *cl = vaddr;
 260         while (clif_dump_packet(clif, address, cl, &size)) {
 261                 cl += size;
 262                 address += size;
 263         }
 264
 265         out(clif, "\n");
 266
 267         clif_process_worklist(clif);
 268 }