rst/rstzip3/rstzip_v2/diffrst.C

// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: diffrst.C
// Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public
// License version 2 as published by the Free Software Foundation.
//
// The above named program is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public
// License along with this work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "rstf/rstf.h"
#include "spix6plus/ITYPES.h"
#include "cpuid.h"

#define ALWAYS (11)
#define NEVER  (12)
#define ATRACE (13)

static int isldst(int ih) {
  return (ih_isload(ih) || ih_isstore(ih));
}

void usage(char* argv[]) {
  fprintf(stderr,
          "Usage: %s [-allowdiff ihash|timestamp]+ rstfile1 rstfile2\n\n",
          argv[0]);
  fprintf(stderr,
          "Reads two rst files, writes nonidentical records to diff.rst.\n"
          "\n"
          "  -allowdiff\n"
          "     ihash       Do not compare ihash values\n"
          "     timestamp   Do not compare cpu timestamp values\n"
          "     ntbranchea  Allow orig nt branch ea to be pc+4 instead of pc+8...\n"
          "     cpuid       Allow cpuid fields to differ\n"
          " rstfile         Use - to read from stdin.\n"
          "\n");
}

int doerror(uint64_t rec, rstf_unionT* rst_orig, rstf_unionT* rst_new, FILE* outfp) {
  rstf_stringT string;

  string.rtype = STRDESC_T;
  sprintf(string.string, "Rec# %llu", rec);

  printf("%s differs\n", string.string);
  fflush(stdout);

  fwrite(&string, sizeof(rstf_stringT), 1, outfp);
  fwrite(rst_orig, sizeof(rstf_unionT), 1, outfp);
  fwrite(rst_new, sizeof(rstf_unionT), 1, outfp);
  fflush(outfp);

  return 1;
}

int main(int argc, char* argv[]) {
  rstf_unionT rst[3];
  FILE* infp0;
  FILE* infp1;
  FILE* outfp;
  bool allowihashdiff;
  bool allowtimestampdiff;
  bool allowntbrancheadiff;
  bool allowcpuiddiff;
  uint64_t i, diffrecs;
  char* a;
  char* b;
  char* filename[2];

  if (argc < 3) {
    usage(argv);
    exit(1);
  }

  // Set default flags
  allowihashdiff = false;
  allowtimestampdiff = false;
  allowntbrancheadiff = false;
  allowcpuiddiff = false;

  // Parse command line args
  for (i = 1; i < argc; i++) {
    a = argv[i];
    b = (i < argc) ? argv[i+1] : NULL;

    if (strcmp("-allowdiff", a) == 0) {
      if (strcmp("ihash", b) == 0) {
        allowihashdiff = true;
      } else if (strcmp("timestamp", b) == 0) {
        allowtimestampdiff = true;
      } else if (strcmp("ntbranchea", b) == 0) {
        allowntbrancheadiff = true;
      } else if (strcmp("cpuid", b) == 0) {
        allowcpuiddiff = true;
      }

      i++;
    } else if (i == argc - 2) {
      if (strcmp("-", a) == 0) {
        infp0 = stdin;
      } else {
        infp0 = fopen(a, "r");
      }

      filename[0] = a;
    } else if (i == argc - 1) {
      if (strcmp("-", a) == 0) {
        infp1 = stdin;
        filename[1] = a;
      } else {
        infp1 = fopen(a, "r");
      }
    } else {
      usage(argv);
      fprintf(stderr, "Error: unknown input parameter %s\n", a);
      exit(1);
    }
  }

  outfp = fopen("diff.rst", "w");
  diffrecs = 0;

  for (i = 0; 1; i++) {
    fread(&rst[0], sizeof(rstf_unionT), 1, infp0);
    fread(&rst[1], sizeof(rstf_unionT), 1, infp1);

    // File size difference?
    if (feof(infp0) || feof(infp1)) {
      break;
    }

    // Are records the different?
    if (memcmp(&rst[0], &rst[1], sizeof(rstf_unionT)) != 0) {
      if (rst[0].proto.rtype == INSTR_T) {
        rst[2] = rst[0];

        // Check ihash
        if (allowihashdiff == true) {
          rst[2].instr.ihash = rst[1].instr.ihash;
        }

        // Check not taken branch ea
        if (allowntbrancheadiff == true) {
          if (ih_isbranch(rst[2].instr.ihash) && rst[2].instr.bt == 0) {
            if (rst[2].instr.ea_va == rst[1].instr.ea_va - 4) {
              rst[2].instr.ea_va = rst[1].instr.ea_va;
            }
          }
        }

        if (allowcpuiddiff == true) {
          rst[2].instr.cpuid = rst[0].instr.cpuid;
        }

        // Ignore invalid ea's
        if (rst[2].instr.ea_valid == 0) {
          rst[2].instr.ea_va = rst[1].instr.ea_va;
        }

        if (memcmp(&rst[2], &rst[1], sizeof(rstf_unionT)) != 0) {
          diffrecs += doerror(i, &rst[0], &rst[1], outfp);
        }
      } else if (rst[0].proto.rtype == CPU_T) {
        if (rst[0].cpu.cpu != rst[1].cpu.cpu) {
          if (allowcpuiddiff == false) {
            diffrecs += doerror(i, &rst[0], &rst[1], outfp);
          }
        } else if (allowtimestampdiff == false) {
          if (rst[0].cpu.timestamp != rst[1].cpu.timestamp) {
            diffrecs += doerror(i, &rst[0], &rst[1], outfp);
          }
        }
      } else if (allowcpuiddiff == true) {
        rst[2] = rst[0];
        setRstCpuID(&rst[2], getRstCpuID(&rst[1]));

        if (memcmp(&rst[2], &rst[1], sizeof(rstf_unionT)) != 0) {
          diffrecs += doerror(i, &rst[0], &rst[1], outfp);
        }
      } else {
        diffrecs += doerror(i, &rst[0], &rst[1], outfp);
      }
    }
  }

  fprintf(stdout, "\nTotal: %llu recs differ\n", diffrecs);

  if (feof(infp0) == 0 || feof(infp1) == 0) {
    fprintf(stdout, "\nWarning: input filesizes differ.\n");
  }

  fclose(infp0);
  fclose(infp1);
  fclose(outfp);

  return 0;
}