xref: /external/valgrind/tsan/ts_offline.cc

/* Copyright (c) 2008-2010, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

// This file is part of ThreadSanitizer, a dynamic data race detector.
// Author: Konstantin Serebryany.
// Author: Timur Iskhodzhanov.

// Experimental off-line race detector.
// Reads program events from a file and detects races.
// See http://code.google.com/p/data-race-test

// ------------- Includes ------------- {{{1
#include "thread_sanitizer.h"
#include "ts_events.h"

#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>

// ------------- Globals ------------- {{{1
static map<string, int> *g_event_type_map;
struct PcInfo {
  string img_name;
  string file_name;
  string rtn_name;
  int line;
};

static map<uintptr_t, PcInfo> *g_pc_info_map;

unsigned long offline_line_n;
//------------- Read binary file Utils ------------ {{{1
static const int kBufSize = 65536;

template<typename T>
static bool Read(FILE *fp, T *res) {
  unsigned char buf[16];
  int size = fread(buf, sizeof(T), 1, fp);
  *res = 0;
  for (unsigned int i=0; i<sizeof(T); i++) {
    *res <<= 8;
    *res += buf[i];
  }
  return size == 1;
}


static bool ReadANSI(FILE *file, string *res) {
  char buf[kBufSize];
  unsigned short length;
  if (!Read<unsigned short>(file, &length)) {
    return false;
  }
  int size = fread(buf, 1, (int)length, file);
  buf[length] = 0;
  *res = (char *)buf;
  return size == length;
}
//------------- Utils ------------------- {{{1
static EventType EventNameToEventType(const char *name) {
  map<string, int>::iterator it = g_event_type_map->find(name);
  if (it == g_event_type_map->end()) {
    Printf("Unknown event type: %s\n", name);
  }
  CHECK(it != g_event_type_map->end());
  return (EventType)it->second;
}

static void InitEventTypeMap() {
  g_event_type_map = new map<string, int>;
  for (int i = 0; i < LAST_EVENT; i++) {
    (*g_event_type_map)[kEventNames[i]] = i;
  }
}

static void SkipCommentText(FILE *file) {
  char buff[kBufSize];
  int i = 0;
  while (true) {
    int c = fgetc(file);
    if (c == EOF) break;
    if (c == '\n') {
      offline_line_n++;
      break;
    }
    if (i < kBufSize - 1)
      buff[i++] = c;
  }
  buff[i] = 0;
  if (buff[0] == 'P' && buff[1] == 'C') {
    char img[kBufSize];
    char rtn[kBufSize];
    char file[kBufSize];
    int line = 0;
    unsigned long pc = 0;
    if (sscanf(buff, "PC %lx %s %s %s %d", (unsigned long*)&pc,
               img, rtn, file, &line) == 5 &&
        pc != 0) {
      CHECK(g_pc_info_map);
      PcInfo pc_info;
      pc_info.img_name = img;
      pc_info.rtn_name = rtn;
      pc_info.file_name = file;
      pc_info.line = line;
      (*g_pc_info_map)[pc] = pc_info;
      // Printf("***** PC %lx %s\n", pc, rtn);
    }
  }
  if (buff[0] == '>') {
    // Just print the rest of comment.
    Printf("%s\n", buff + 2);
  }
}

static void SkipWhiteSpaceAndComments(FILE *file) {
  int c = 0;
  while (true) {
    c = fgetc(file);
    if (c == EOF) return;
    if (c == '#' || c == '=') {
      SkipCommentText(file);
      continue;
    }
    if (isspace(c)) continue;
    break;
  }
  ungetc(c, file);
}

typedef bool (*EventReader)(FILE *, Event *);

bool ReadOneStrEventFromFile(FILE *file, Event *event) {
  CHECK(event);
  char name[1024];
  uint32_t tid;
  unsigned long pc, a, info;
  SkipWhiteSpaceAndComments(file);
  offline_line_n++;
  if (5 == fscanf(file, "%s%x%lx%lx%lx", name, &tid, &pc, &a, &info)) {
    event->Init(EventNameToEventType(name), tid, pc, a, info);
    return true;
  }
  return false;
}

bool ProcessCodePosition(FILE *input, int *pc, string *str) {
  bool ok = Read<int>(input, pc);
  ok &= ReadANSI(input, str);
  return ok;
}

bool ProcessMessage(FILE *input, string *str) {
  return ReadANSI(input, str);
}

// Read information about event in format: [[[info] address] pc] tid.
bool ProcessEvent(FILE *input, EventType type, Event *event) {
  bool ok = true;
  unsigned short tid = 0;
  int pc = 0;
  int64_t address = 0;
  unsigned short extra = 0;
  // It's tricky switch without breaks.
  switch (type) {
    case THR_START:
      ok &= Read<unsigned short>(input, &extra);
      // fallthrough.
    case READ:
    case READER_LOCK:
    case SIGNAL:
    case THR_JOIN_AFTER:
    case UNLOCK:
    case WAIT:
    case WRITE:
    case WRITER_LOCK:
      ok &= Read<int64_t>(input, &address);
      // fallthrough.
    case EXPECT_RACE_BEGIN:
    case EXPECT_RACE_END:
    case RTN_EXIT:
    case SBLOCK_ENTER:
    case STACK_TRACE:
    case THR_END:
    case THR_FIRST_INSN:
      ok &= Read<int>(input, &pc);
      // fallthrough.
    case RTN_CALL:
      ok &= Read<unsigned short>(input, &tid);
      break;
    default:
      // read unsupported EventType.
      Printf("Unsupported EventType %s %d\n", type, (int)type);
      CHECK(false);
  }
  if (type == READ || type == WRITE) {
    extra = 1;
  }
  event->Init(type, (int)tid, pc, address, (int)extra);
  return ok;
}

bool ReadOneBinEventFromFile(FILE *input, Event *event) {
  CHECK(event);
  bool ok = true;
  EventType type;
  unsigned char typeOrd;
  int pc;
  int line;
  char rtn[kBufSize];
  char file[kBufSize];
  string str;
  while (ok) {
    offline_line_n++;
    ok &= Read<unsigned char>(input, &typeOrd);
    if (!ok) break;
    type = (EventType)typeOrd;
    switch (type) {
      case PC_DESCRIPTION:
        ok &= ProcessCodePosition(input, &pc, &str);
        if (sscanf(str.c_str(), "%s %s %d", rtn, file, &line) == 3 && pc != 0) {
          CHECK(g_pc_info_map);
          PcInfo pc_info;
          pc_info.img_name = "java";
          pc_info.rtn_name = rtn;
          pc_info.file_name = file;
          pc_info.line = line;
          (*g_pc_info_map)[pc] = pc_info;
        }
        break;
      case PRINT_MESSAGE:
        ok &= ProcessMessage(input, &str);
        // Just print the rest of comment.
        Printf("%s\n", str.c_str());
        break;
      default:
        ok &= ProcessEvent(input, type, event);
        return ok;
    }
  }
  return false;
}

void DecodeEventsFromFile(FILE *input, FILE *output) {
  offline_line_n = 0;
  bool ok = true;
  EventType type;
  unsigned char typeOrd;
  int pc;
  string str;
  Event event;
  while (ok) {
    ok &= Read<unsigned char>(input, &typeOrd);
    if (!ok) break;
    type = (EventType)typeOrd;
    switch (type) {
      case PC_DESCRIPTION:
        ok &= ProcessCodePosition(input, &pc, &str);
        fprintf(output, "#PC %x java %s\n", pc, str.c_str());
        break;
      case PRINT_MESSAGE:
        ok &= ProcessMessage(input, &str);
        fprintf(output, "#> %s\n", str.c_str());
        break;
      default:
        ok &= ProcessEvent(input, type, &event);
        fprintf(output, "%s %x %x %lx %lx\n", kEventNames[event.type()],
            event.tid(), (unsigned int)event.pc(),
            (long unsigned int)event.a(), (long unsigned int)event.info());
        break;
    }
    offline_line_n++;
  }
  Printf("INFO: ThreadSanitizer write %ld lines.\n", offline_line_n);
}

static const uint32_t max_unknown_thread = 10000;

static bool known_threads[max_unknown_thread] = {};

INLINE void ReadEventsFromFile(FILE *file, EventReader event_reader_cb) {
  Event event;
  uint64_t n_events = 0;
  offline_line_n = 0;
  while (event_reader_cb(file, &event)) {
    //event.Print();
    n_events++;
    uint32_t tid = event.tid();
    if (event.type() == THR_START && tid < max_unknown_thread) {
      known_threads[tid] = true;
    }
    if (tid >= max_unknown_thread || known_threads[tid]) {
      ThreadSanitizerHandleOneEvent(&event);
    }
  }
  Printf("INFO: ThreadSanitizerOffline: %ld events read\n", n_events);
}
//------------- ThreadSanitizer exports ------------ {{{1

void PcToStrings(uintptr_t pc, bool demangle,
                string *img_name, string *rtn_name,
                string *file_name, int *line_no) {
  if (g_pc_info_map->count(pc) == 0) {
    *img_name = "";
    *rtn_name = "";
    *file_name = "";
    *line_no = 0;
    return;
  }
  PcInfo &info = (*g_pc_info_map)[pc];
  *img_name = info.img_name;
  *rtn_name = info.rtn_name;
  *file_name = info.file_name;
  *line_no = info.line;
  if (*file_name == "unknown")
    *file_name = "";
}

string PcToRtnName(uintptr_t pc, bool demangle) {
  string img, rtn, file;
  int line;
  PcToStrings(pc, demangle, &img, &rtn, &file, &line);
  return rtn;
}
//------------- main ---------------------------- {{{1
int main(int argc, char *argv[]) {
  Printf("INFO: ThreadSanitizerOffline r%s\n", TS_VERSION);

  InitEventTypeMap();
  g_pc_info_map = new map<uintptr_t, PcInfo>;
  G_flags = new FLAGS;

  vector<string> args(argv + 1, argv + argc);
  ThreadSanitizerParseFlags(&args);
  ThreadSanitizerInit();

  CHECK(G_flags);
  if (G_flags->input_type == "bin") {
    ReadEventsFromFile(stdin, ReadOneBinEventFromFile);
  } else if (G_flags->input_type == "decode") {
    FILE* output;
    if (G_flags->log_file.size() > 0) {
      output = fopen(G_flags->log_file.c_str(), "w");
    } else {
      output = stdout;
    }
    DecodeEventsFromFile(stdin, output);
  } else if (G_flags->input_type == "str") {
    ReadEventsFromFile(stdin, ReadOneStrEventFromFile);
  } else {
    Printf("Error: Unknown input_type value %s\n", G_flags->input_type.c_str());
    exit(5);
  }

  ThreadSanitizerFini();
  if (G_flags->error_exitcode && GetNumberOfFoundErrors() > 0) {
    return G_flags->error_exitcode;
  }
}

// end. {{{1
// vim:shiftwidth=2:softtabstop=2:expandtab:tw=80