src/gallium/drivers/etnaviv/etnaviv_disasm.c

   1 /*
   2  * Copyright (c) 2016 Etnaviv Project
   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, sub license,
   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
  12  * next paragraph) shall be included in all copies or substantial portions
  13  * of the 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 NON-INFRINGEMENT. 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
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Christian Gmeiner <christian.gmeiner@gmail.com>
  25  */
  26
  27 #include "etnaviv_disasm.h"
  28
  29 #include <assert.h>
  30 #include <stdbool.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33
  34 #include "hw/isa.xml.h"
  35
  36 struct instr {
  37    /* dword0: */
  38    uint32_t opc         : 6;
  39    uint32_t cond        : 5;
  40    uint32_t sat         : 1;
  41    uint32_t dst_use     : 1;
  42    uint32_t dst_amode   : 3;
  43    uint32_t dst_reg     : 7;
  44    uint32_t dst_comps   : 4;
  45    uint32_t tex_id      : 5;
  46
  47    /* dword1: */
  48    uint32_t tex_amode   : 3;
  49    uint32_t tex_swiz    : 8;
  50    uint32_t src0_use    : 1;
  51    uint32_t src0_reg    : 9;
  52    uint32_t type_bit2   : 1;
  53    uint32_t src0_swiz   : 8;
  54    uint32_t src0_neg    : 1;
  55    uint32_t src0_abs    : 1;
  56
  57    /* dword2: */
  58    uint32_t src0_amode  : 3;
  59    uint32_t src0_rgroup : 3;
  60    uint32_t src1_use    : 1;
  61    uint32_t src1_reg    : 9;
  62    uint32_t opcode_bit6 : 1;
  63    uint32_t src1_swiz   : 8;
  64    uint32_t src1_neg    : 1;
  65    uint32_t src1_abs    : 1;
  66    uint32_t src1_amode  : 3;
  67    uint32_t type_bit01  : 2;
  68
  69    /* dword3: */
  70    union {
  71       struct {
  72          uint32_t src1_rgroup : 3;
  73          uint32_t src2_use    : 1;
  74          uint32_t src2_reg    : 9;
  75          uint32_t unk3_13     : 1;
  76          uint32_t src2_swiz   : 8;
  77          uint32_t src2_neg    : 1;
  78          uint32_t src2_abs    : 1;
  79          uint32_t unk3_24     : 1;
  80          uint32_t src2_amode  : 3;
  81          uint32_t src2_rgroup : 3;
  82          uint32_t unk3_31     : 1;
  83       };
  84       uint32_t dword3;
  85    };
  86 };
  87
  88 struct dst_operand {
  89    bool use;
  90    uint8_t amode;
  91    uint16_t reg;
  92    uint8_t comps;
  93 };
  94
  95 struct src_operand {
  96    bool use;
  97    bool neg;
  98    bool abs;
  99    uint8_t rgroup;
 100    uint16_t reg;
 101    uint8_t swiz;
 102    uint8_t amode;
 103 };
 104
 105 struct tex_operand {
 106    uint8_t id;
 107    uint8_t amode;
 108    uint8_t swiz;
 109 };
 110
 111 struct opc_operands {
 112    struct dst_operand *dst;
 113    struct tex_operand *tex;
 114    struct src_operand *src0;
 115    struct src_operand *src1;
 116    struct src_operand *src2;
 117
 118    int imm;
 119 };
 120
 121 static void
 122 printf_type(uint8_t type)
 123 {
 124    switch(type) {
 125    case INST_TYPE_F32:
 126       /* as f32 is the default print nothing */
 127       break;
 128
 129    case INST_TYPE_S32:
 130       printf(".s32");
 131       break;
 132
 133    case INST_TYPE_S8:
 134       printf(".s8");
 135       break;
 136
 137    case INST_TYPE_U16:
 138       printf(".u16");
 139       break;
 140
 141    case INST_TYPE_F16:
 142       printf(".f16");
 143       break;
 144
 145    case INST_TYPE_S16:
 146       printf(".s16");
 147       break;
 148
 149    case INST_TYPE_U32:
 150       printf(".u32");
 151       break;
 152
 153    case INST_TYPE_U8:
 154       printf(".u8");
 155       break;
 156
 157    default:
 158       abort();
 159       break;
 160    }
 161 }
 162
 163 static void
 164 print_condition(uint8_t condition)
 165 {
 166    switch (condition) {
 167    case INST_CONDITION_TRUE:
 168       break;
 169
 170    case INST_CONDITION_GT:
 171       printf(".GT");
 172       break;
 173
 174    case INST_CONDITION_LT:
 175       printf(".LT");
 176       break;
 177
 178    case INST_CONDITION_GE:
 179       printf(".GE");
 180       break;
 181
 182    case INST_CONDITION_LE:
 183       printf(".LE");
 184       break;
 185
 186    case INST_CONDITION_EQ:
 187       printf(".EQ");
 188       break;
 189
 190    case INST_CONDITION_NE:
 191       printf(".NE");
 192       break;
 193
 194    case INST_CONDITION_AND:
 195       printf(".AND");
 196       break;
 197
 198    case INST_CONDITION_OR:
 199       printf(".OR");
 200       break;
 201
 202    case INST_CONDITION_XOR:
 203       printf(".XOR");
 204       break;
 205
 206    case INST_CONDITION_NOT:
 207       printf(".NOT");
 208       break;
 209
 210    case INST_CONDITION_NZ:
 211       printf(".NZ");
 212       break;
 213
 214    case INST_CONDITION_GEZ:
 215       printf(".GEZ");
 216       break;
 217
 218    case INST_CONDITION_GZ:
 219       printf(".GZ");
 220       break;
 221
 222    case INST_CONDITION_LEZ:
 223       printf(".LEZ");
 224       break;
 225
 226    case INST_CONDITION_LZ:
 227       printf(".LZ");
 228       break;
 229
 230    default:
 231       abort();
 232       break;
 233    }
 234 }
 235
 236 static void
 237 print_rgroup(uint8_t rgoup)
 238 {
 239    switch (rgoup) {
 240    case INST_RGROUP_TEMP:
 241       printf("t");
 242       break;
 243
 244    case INST_RGROUP_INTERNAL:
 245       printf("i");
 246       break;
 247
 248    case INST_RGROUP_UNIFORM_0:
 249    case INST_RGROUP_UNIFORM_1:
 250       printf("u");
 251       break;
 252    }
 253 }
 254
 255 static void
 256 print_components(uint8_t components)
 257 {
 258    if (components == 15)
 259       return;
 260
 261    printf(".");
 262    if (components & INST_COMPS_X)
 263       printf("x");
 264    else
 265       printf("_");
 266
 267    if (components & INST_COMPS_Y)
 268       printf("y");
 269    else
 270       printf("_");
 271
 272    if (components & INST_COMPS_Z)
 273       printf("z");
 274    else
 275       printf("_");
 276
 277    if (components & INST_COMPS_W)
 278       printf("w");
 279    else
 280       printf("_");
 281 }
 282
 283 static inline void
 284 print_swiz_comp(uint8_t swiz_comp)
 285 {
 286    switch (swiz_comp) {
 287    case INST_SWIZ_COMP_X:
 288       printf("x");
 289       break;
 290
 291    case INST_SWIZ_COMP_Y:
 292       printf("y");
 293       break;
 294
 295    case INST_SWIZ_COMP_Z:
 296       printf("z");
 297       break;
 298
 299    case INST_SWIZ_COMP_W:
 300       printf("w");
 301       break;
 302
 303    default:
 304       abort();
 305       break;
 306    }
 307 }
 308
 309 static void
 310 print_swiz(uint8_t swiz)
 311 {
 312    // if a null swizzle
 313    if (swiz == 0xe4)
 314       return;
 315
 316    const unsigned x = swiz & 0x3;
 317    const unsigned y = (swiz & 0x0C) >> 2;
 318    const unsigned z = (swiz & 0x30) >> 4;
 319    const unsigned w = (swiz & 0xc0) >> 6;
 320
 321    printf(".");
 322    print_swiz_comp(x);
 323    print_swiz_comp(y);
 324    print_swiz_comp(z);
 325    print_swiz_comp(w);
 326 }
 327
 328 static void
 329 print_amode(uint8_t amode)
 330 {
 331    switch (amode) {
 332    case INST_AMODE_DIRECT:
 333       /* nothing to output */
 334       break;
 335
 336    case INST_AMODE_ADD_A_X:
 337       printf("[a.x]");
 338       break;
 339
 340    case INST_AMODE_ADD_A_Y:
 341       printf("[a.y]");
 342       break;
 343
 344    case INST_AMODE_ADD_A_Z:
 345       printf("[a.z]");
 346       break;
 347
 348    case INST_AMODE_ADD_A_W:
 349       printf("[a.w]");
 350       break;
 351
 352    default:
 353       abort();
 354       break;
 355    }
 356 }
 357
 358 static void
 359 print_dst(struct dst_operand *dst, bool sep)
 360 {
 361    if (dst->use) {
 362       printf("t%u", dst->reg);
 363       print_amode(dst->amode);
 364       print_components(dst->comps);
 365    } else {
 366       printf("void");
 367    }
 368
 369    if (sep)
 370       printf(", ");
 371 }
 372
 373 static void
 374 print_tex(struct tex_operand *tex, bool sep)
 375 {
 376    printf("tex%u", tex->id);
 377    print_amode(tex->amode);
 378    print_swiz(tex->swiz);
 379
 380    if (sep)
 381       printf(", ");
 382 }
 383
 384 static void
 385 print_src(struct src_operand *src, bool sep)
 386 {
 387    if (src->use) {
 388       if (src->neg)
 389          printf("-");
 390
 391       if (src->abs)
 392          printf("|");
 393
 394       if (src->rgroup == INST_RGROUP_UNIFORM_1)
 395          src->reg += 128;
 396
 397       print_rgroup(src->rgroup);
 398       printf("%u", src->reg);
 399       print_amode(src->amode);
 400       print_swiz(src->swiz);
 401
 402       if (src->abs)
 403          printf("|");
 404    } else {
 405       printf("void");
 406    }
 407
 408    if (sep)
 409       printf(", ");
 410 }
 411
 412 static void
 413 print_opc_default(struct opc_operands *operands)
 414 {
 415    print_dst(operands->dst, true);
 416    print_src(operands->src0, true);
 417    print_src(operands->src1, true);
 418    print_src(operands->src2, false);
 419 }
 420
 421 static void
 422 print_opc_mov(struct opc_operands *operands)
 423 {
 424    // dst (areg)
 425    printf("a%u", operands->dst->reg);
 426    print_components(operands->dst->comps);
 427    printf(", ");
 428
 429    print_src(operands->src0, true);
 430    print_src(operands->src1, true);
 431    print_src(operands->src2, false);
 432 }
 433
 434 static void
 435 print_opc_tex(struct opc_operands *operands)
 436 {
 437    print_dst(operands->dst, true);
 438    print_tex(operands->tex, true);
 439    print_src(operands->src0, true);
 440    print_src(operands->src1, true);
 441    print_src(operands->src2, false);
 442 }
 443
 444 static void
 445 print_opc_imm(struct opc_operands *operands)
 446 {
 447    print_dst(operands->dst, true);
 448    print_src(operands->src0, true);
 449    print_src(operands->src1, true);
 450    printf("label_%04d", operands->imm);
 451 }
 452
 453 #define OPC_BITS 7
 454
 455 static const struct opc_info {
 456    const char *name;
 457    void (*print)(struct opc_operands *operands);
 458 } opcs[1 << OPC_BITS] = {
 459 #define OPC(opc) [INST_OPCODE_##opc] = {#opc, print_opc_default}
 460 #define OPC_MOV(opc) [INST_OPCODE_##opc] = {#opc, print_opc_mov}
 461 #define OPC_TEX(opc) [INST_OPCODE_##opc] = {#opc, print_opc_tex}
 462 #define OPC_IMM(opc) [INST_OPCODE_##opc] = {#opc, print_opc_imm}
 463    OPC(NOP),
 464    OPC(ADD),
 465    OPC(MAD),
 466    OPC(MUL),
 467    OPC(DST),
 468    OPC(DP3),
 469    OPC(DP4),
 470    OPC(DSX),
 471    OPC(DSY),
 472    OPC(MOV),
 473    OPC_MOV(MOVAR),
 474    OPC_MOV(MOVAF),
 475    OPC(RCP),
 476    OPC(RSQ),
 477    OPC(LITP),
 478    OPC(SELECT),
 479    OPC(SET),
 480    OPC(EXP),
 481    OPC(LOG),
 482    OPC(FRC),
 483    OPC_IMM(CALL),
 484    OPC(RET),
 485    OPC_IMM(BRANCH),
 486    OPC_TEX(TEXKILL),
 487    OPC_TEX(TEXLD),
 488    OPC_TEX(TEXLDB),
 489    OPC_TEX(TEXLDD),
 490    OPC_TEX(TEXLDL),
 491    OPC_TEX(TEXLDPCF),
 492    OPC(REP),
 493    OPC(ENDREP),
 494    OPC(LOOP),
 495    OPC(ENDLOOP),
 496    OPC(SQRT),
 497    OPC(SIN),
 498    OPC(COS),
 499    OPC(FLOOR),
 500    OPC(CEIL),
 501    OPC(SIGN),
 502    OPC(I2F),
 503    OPC(CMP),
 504    OPC(LOAD),
 505    OPC(STORE),
 506    OPC(IMULLO0),
 507    OPC(IMULHI0),
 508    OPC(LEADZERO),
 509    OPC(LSHIFT),
 510    OPC(RSHIFT),
 511    OPC(ROTATE),
 512    OPC(OR),
 513    OPC(AND),
 514    OPC(XOR),
 515    OPC(NOT),
 516 };
 517
 518 static void
 519 print_instr(uint32_t *dwords, int n, enum debug_t debug)
 520 {
 521    struct instr *instr = (struct instr *)dwords;
 522    const unsigned opc = instr->opc | (instr->opcode_bit6 << 6);
 523    const char *name = opcs[opc].name;
 524
 525    printf("%04d: ", n);
 526    if (debug & PRINT_RAW)
 527       printf("%08x %08x %08x %08x  ", dwords[0], dwords[1], dwords[2],
 528              dwords[3]);
 529
 530    if (name) {
 531
 532       struct dst_operand dst = {
 533          .use = instr->dst_use,
 534          .amode = instr->dst_amode,
 535          .reg = instr->dst_reg,
 536          .comps = instr->dst_comps
 537       };
 538
 539       struct tex_operand tex = {
 540          .id = instr->tex_id,
 541          .amode = instr->tex_amode,
 542          .swiz = instr->tex_swiz,
 543       };
 544
 545       struct src_operand src0 = {
 546          .use = instr->src0_use,
 547          .neg = instr->src0_neg,
 548          .abs = instr->src0_abs,
 549          .rgroup = instr->src0_rgroup,
 550          .reg = instr->src0_reg,
 551          .swiz = instr->src0_swiz,
 552          .amode = instr->src0_amode,
 553       };
 554
 555       struct src_operand src1 = {
 556          .use = instr->src1_use,
 557          .neg = instr->src1_neg,
 558          .abs = instr->src1_abs,
 559          .rgroup = instr->src1_rgroup,
 560          .reg = instr->src1_reg,
 561          .swiz = instr->src1_swiz,
 562          .amode = instr->src1_amode,
 563       };
 564
 565       struct src_operand src2 = {
 566          .use = instr->src2_use,
 567          .neg = instr->src2_neg,
 568          .abs = instr->src2_abs,
 569          .rgroup = instr->src2_rgroup,
 570          .reg = instr->src2_reg,
 571          .swiz = instr->src2_swiz,
 572          .amode = instr->src2_amode,
 573       };
 574
 575       int imm = (instr->dword3 & VIV_ISA_WORD_3_SRC2_IMM__MASK)
 576                 >> VIV_ISA_WORD_3_SRC2_IMM__SHIFT;
 577
 578       struct opc_operands operands = {
 579          .dst = &dst,
 580          .tex = &tex,
 581          .src0 = &src0,
 582          .src1 = &src1,
 583          .src2 = &src2,
 584          .imm = imm,
 585       };
 586
 587       uint8_t type = instr->type_bit01 | (instr->type_bit2 << 2);
 588
 589       printf("%s", name);
 590       printf_type(type);
 591       if (instr->sat)
 592          printf(".SAT");
 593       print_condition(instr->cond);
 594       printf(" ");
 595       opcs[opc].print(&operands);
 596    } else {
 597       printf("unknown (%d)", instr->opc);
 598    }
 599
 600    printf("\n");
 601 }
 602
 603 void
 604 etna_disasm(uint32_t *dwords, int sizedwords, enum debug_t debug)
 605 {
 606    unsigned i;
 607
 608    assert((sizedwords % 2) == 0);
 609
 610    for (i = 0; i < sizedwords; i += 4)
 611       print_instr(&dwords[i], i / 4, debug);
 612 }