Mesa (master): aubinator: Fix the decoding of values that span two Dwords

[Kenneth Graunke]

Module: Mesa
Branch: master
Commit: 8e3e9d74b54dc9dda0432f69fdbb2eab5969cc8a
URL:    http://cgit.freedesktop.org/mesa/mesa/commit/?id=8e3e9d74b54dc9dda0432f69fdbb2eab5969cc8a

Author: Sirisha Gandikota <Sirisha.Gandikota at intel.com>
Date:   Tue Sep 20 15:59:28 2016 -0700

aubinator: Fix the decoding of values that span two Dwords

Fixed the way the values that span two Dwords are decoded.
Based on the start and end indices of the field, the Dwords
are fetched and decoded accordingly.

v2: rename dw to qw in gen_field_iterator_next
and remove extra white space (Anuj)

v3: change all instances of dw to qw (Anuj)

Earlier, 64-bit fields (such as most pointers on Gen8+)
weren't decoded correctly.  gen_field_iterator_next seemed
to walk one DWord at a time, sets v.dw, and then passes it
to field(). So, even though field() takes a uint64_t, we're
passing it a uint32_t (which gets promoted, so the top 32
bits will always be zero). This seems pretty bogus... (Ken)

Signed-off-by: Sirisha Gandikota <Sirisha.Gandikota at intel.com>
Reviewed-by: Anuj Phogat <anuj.phogat at gmail.com>
Reviewed-by: Kenneth Graunke <kenneth at whitecape.org>

---

 src/intel/tools/decoder.c | 50 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 37 insertions(+), 13 deletions(-)

diff --git a/src/intel/tools/decoder.c b/src/intel/tools/decoder.c
index b5f557c..be3558b 100644
--- a/src/intel/tools/decoder.c
+++ b/src/intel/tools/decoder.c
@@ -191,6 +191,26 @@ get_register_offset(const char **atts, uint32_t *offset)
    return;
 }
 
+static void
+get_start_end_pos(int *start, int *end)
+{
+   /* start value has to be mod with 32 as we need the relative
+    * start position in the first DWord. For the end position, add
+    * the length of the field to the start position to get the
+    * relative postion in the 64 bit address.
+    */
+   if (*end - *start > 32) {
+      int len = *end - *start;
+      *start = *start % 32;
+      *end = *start + len;
+   } else {
+      *start = *start % 32;
+      *end = *end % 32;
+   }
+
+   return;
+}
+
 static inline uint64_t
 mask(int start, int end)
 {
@@ -204,18 +224,16 @@ mask(int start, int end)
 static inline uint64_t
 field(uint64_t value, int start, int end)
 {
-   /* The field values are obtained from the DWord,
-    * Hence, get the relative start and end positions
-    * by doing a %32 on the start and end positions
-    */
-   return (value & mask(start % 32, end % 32)) >> (start % 32);
+   get_start_end_pos(&start, &end);
+   return (value & mask(start, end)) >> (start);
 }
 
 static inline uint64_t
 field_address(uint64_t value, int start, int end)
 {
    /* no need to right shift for address/offset */
-   return (value & mask(start % 32, end % 32));
+   get_start_end_pos(&start, &end);
+   return (value & mask(start, end));
 }
 
 static struct gen_type
@@ -491,7 +509,7 @@ gen_field_iterator_next(struct gen_field_iterator *iter)
 {
    struct gen_field *f;
    union {
-      uint32_t dw;
+      uint64_t qw;
       float f;
    } v;
 
@@ -500,20 +518,26 @@ gen_field_iterator_next(struct gen_field_iterator *iter)
 
    f = iter->group->fields[iter->i++];
    iter->name = f->name;
-   v.dw = iter->p[f->start / 32];
+   int index = f->start / 32;
+
+   if ((f->end - f->start) > 32)
+      v.qw = ((uint64_t) iter->p[index+1] << 32) | iter->p[index];
+   else
+      v.qw = iter->p[index];
+
    switch (f->type.kind) {
    case GEN_TYPE_UNKNOWN:
    case GEN_TYPE_INT:
       snprintf(iter->value, sizeof(iter->value),
-               "%ld", field(v.dw, f->start, f->end));
+               "%ld", field(v.qw, f->start, f->end));
       break;
    case GEN_TYPE_UINT:
       snprintf(iter->value, sizeof(iter->value),
-               "%lu", field(v.dw, f->start, f->end));
+               "%lu", field(v.qw, f->start, f->end));
       break;
    case GEN_TYPE_BOOL:
       snprintf(iter->value, sizeof(iter->value),
-               "%s", field(v.dw, f->start, f->end) ? "true" : "false");
+               "%s", field(v.qw, f->start, f->end) ? "true" : "false");
       break;
    case GEN_TYPE_FLOAT:
       snprintf(iter->value, sizeof(iter->value), "%f", v.f);
@@ -521,7 +545,7 @@ gen_field_iterator_next(struct gen_field_iterator *iter)
    case GEN_TYPE_ADDRESS:
    case GEN_TYPE_OFFSET:
       snprintf(iter->value, sizeof(iter->value),
-               "0x%08lx", field_address(v.dw, f->start, f->end));
+               "0x%08lx", field_address(v.qw, f->start, f->end));
       break;
    case GEN_TYPE_STRUCT:
       snprintf(iter->value, sizeof(iter->value),
@@ -529,7 +553,7 @@ gen_field_iterator_next(struct gen_field_iterator *iter)
       break;
    case GEN_TYPE_UFIXED:
       snprintf(iter->value, sizeof(iter->value),
-               "%f", (float) field(v.dw, f->start, f->end) / (1 << f->type.f));
+               "%f", (float) field(v.qw, f->start, f->end) / (1 << f->type.f));
       break;
    case GEN_TYPE_SFIXED:
       /* FIXME: Sign extend extracted field. */