/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "asm/macroAssembler.hpp"

#include "ci/ciUtilities.hpp"

#include "classfile/javaClasses.hpp"

#include "code/codeCache.hpp"

#include "compiler/disassembler.hpp"

#include "gc/shared/cardTable.hpp"

#include "gc/shared/cardTableBarrierSet.hpp"

#include "gc/shared/collectedHeap.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "runtime/stubRoutines.hpp"

#include "utilities/resourceHash.hpp"

#include CPU_HEADER(depChecker)

void*       Disassembler::_library               = NULL;

bool        Disassembler::_tried_to_load_library = false;

// This routine is in the shared library:

Disassembler::decode_func_virtual Disassembler::_decode_instructions_virtual = NULL;

Disassembler::decode_func Disassembler::_decode_instructions = NULL;

static const char hsdis_library_name[] = "hsdis-" HOTSPOT_LIB_ARCH;

static const char decode_instructions_virtual_name[] = "decode_instructions_virtual";

static const char decode_instructions_name[] = "decode_instructions";

static bool use_new_version = true;

#define COMMENT_COLUMN  52 LP64_ONLY(+8) /*could be an option*/

#define BYTES_COMMENT   ";..."  /* funky byte display comment */

bool Disassembler::load_library() {

  if (_decode_instructions_virtual != NULL || _decode_instructions != NULL) {

    // Already succeeded.

    return true;

  }

  if (_tried_to_load_library) {

    // Do not try twice.

    // To force retry in debugger: assign _tried_to_load_library=0

    return false;

  }

  // Try to load it.

  char ebuf[1024];

  char buf[JVM_MAXPATHLEN];

  os::jvm_path(buf, sizeof(buf));

  int jvm_offset = -1;

  int lib_offset = -1;

#ifdef STATIC_BUILD

  char* p = strrchr(buf, '/');

  *p = '\0';

  strcat(p, "/lib/");

  lib_offset = jvm_offset = strlen(buf);

#else

  {

    // Match "jvm[^/]*" in jvm_path.

    const char* base = buf;

    const char* p = strrchr(buf, *os::file_separator());

    if (p != NULL) lib_offset = p - base + 1;

    p = strstr(p ? p : base, "jvm");

    if (p != NULL) jvm_offset = p - base;

  }

#endif

  // Find the disassembler shared library.

  // Search for several paths derived from libjvm, in this order:

  // 1. <home>/jre/lib/<arch>/<vm>/libhsdis-<arch>.so  (for compatibility)

  // 2. <home>/jre/lib/<arch>/<vm>/hsdis-<arch>.so

  // 3. <home>/jre/lib/<arch>/hsdis-<arch>.so

  // 4. hsdis-<arch>.so  (using LD_LIBRARY_PATH)

  if (jvm_offset >= 0) {

    // 1. <home>/jre/lib/<arch>/<vm>/libhsdis-<arch>.so

    strcpy(&buf[jvm_offset], hsdis_library_name);

    strcat(&buf[jvm_offset], os::dll_file_extension());

    _library = os::dll_load(buf, ebuf, sizeof ebuf);

    if (_library == NULL && lib_offset >= 0) {

      // 2. <home>/jre/lib/<arch>/<vm>/hsdis-<arch>.so

      strcpy(&buf[lib_offset], hsdis_library_name);

      strcat(&buf[lib_offset], os::dll_file_extension());

      _library = os::dll_load(buf, ebuf, sizeof ebuf);

    }

    if (_library == NULL && lib_offset > 0) {

      // 3. <home>/jre/lib/<arch>/hsdis-<arch>.so

      buf[lib_offset - 1] = '\0';

      const char* p = strrchr(buf, *os::file_separator());

      if (p != NULL) {

        lib_offset = p - buf + 1;

        strcpy(&buf[lib_offset], hsdis_library_name);

        strcat(&buf[lib_offset], os::dll_file_extension());

        _library = os::dll_load(buf, ebuf, sizeof ebuf);

      }

    }

  }

  if (_library == NULL) {

    // 4. hsdis-<arch>.so  (using LD_LIBRARY_PATH)

    strcpy(&buf[0], hsdis_library_name);

    strcat(&buf[0], os::dll_file_extension());

    _library = os::dll_load(buf, ebuf, sizeof ebuf);

  }

  if (_library != NULL) {

    _decode_instructions_virtual = CAST_TO_FN_PTR(Disassembler::decode_func_virtual,

                                          os::dll_lookup(_library, decode_instructions_virtual_name));

  }

  if (_decode_instructions_virtual == NULL && _library != NULL) {

    // could not spot in new version, try old version

    _decode_instructions = CAST_TO_FN_PTR(Disassembler::decode_func,

                                          os::dll_lookup(_library, decode_instructions_name));

    use_new_version = false;

  } else {

    use_new_version = true;

  }

  _tried_to_load_library = true;

  if (_decode_instructions_virtual == NULL && _decode_instructions == NULL) {

    tty->print_cr("Could not load %s; %s; %s", buf,

                  ((_library != NULL)

                   ? "entry point is missing"

                   : (WizardMode || PrintMiscellaneous)

                   ? (const char*)ebuf

                   : "library not loadable"),

                  "PrintAssembly is disabled");

    return false;

  }

  // Success.

  tty->print_cr("Loaded disassembler from %s", buf);

  return true;

}

class decode_env {

 private:

  nmethod*      _nm;

  CodeBlob*     _code;

  CodeStrings   _strings;

  outputStream* _output;

  address       _start, _end;

  ptrdiff_t     _offset;

  char          _option_buf[512];

  char          _print_raw;

  bool          _print_pc;

  bool          _print_bytes;

  address       _cur_insn;

  int           _bytes_per_line; // arch-specific formatting option

  bool          _print_file_name;

  static bool match(const char* event, const char* tag) {

    size_t taglen = strlen(tag);

    if (strncmp(event, tag, taglen) != 0)

      return false;

    char delim = event[taglen];

    return delim == '\0' || delim == ' ' || delim == '/' || delim == '=';

  }

  void collect_options(const char* p) {

    if (p == NULL || p[0] == '\0')  return;

    size_t opt_so_far = strlen(_option_buf);

    if (opt_so_far + 1 + strlen(p) + 1 > sizeof(_option_buf))  return;

    char* fillp = &_option_buf[opt_so_far];

    if (opt_so_far > 0) *fillp++ = ',';

    strcat(fillp, p);

    // replace white space by commas:

    char* q = fillp;

    while ((q = strpbrk(q, " \t\n")) != NULL)

      *q++ = ',';

    // Note that multiple PrintAssemblyOptions flags accumulate with \n,

    // which we want to be changed to a comma...

  }

  void print_insn_labels();

  void print_insn_bytes(address pc0, address pc);

  void print_address(address value);

  struct SourceFileInfo {

    struct Link : public CHeapObj<mtCode> {

      const char* file;

      int line;

      Link* next;

      Link(const char* f, int l) : file(f), line(l), next(NULL) {}

    };

    Link *head, *tail;

    static unsigned hash(const address& a) {

      return primitive_hash<address>(a);

    }

    static bool equals(const address& a0, const address& a1) {

      return primitive_equals<address>(a0, a1);

    }

    void append(const char* file, int line) {

      if (tail != NULL && tail->file == file && tail->line == line) {

        // Don't print duplicated lines at the same address. This could happen with C

        // macros that end up having multiple "__" tokens on the same __LINE__.

        return;

      }

      Link *link = new Link(file, line);

      if (head == NULL) {

        head = tail = link;

      } else {

        tail->next = link;

        tail = link;

      }

    }

    SourceFileInfo(const char* file, int line) : head(NULL), tail(NULL) {

      append(file, line);

    }

  };

  typedef ResourceHashtable<

      address, SourceFileInfo,

      SourceFileInfo::hash,

      SourceFileInfo::equals,

      15889,      // prime number

      ResourceObj::C_HEAP> SourceFileInfoTable;

  static SourceFileInfoTable _src_table;

  static const char* _cached_src;

  static GrowableArray<const char*>* _cached_src_lines;

 public:

  decode_env(CodeBlob* code, outputStream* output,

             CodeStrings c = CodeStrings(), ptrdiff_t offset = 0);

  address decode_instructions(address start, address end);

  void start_insn(address pc) {

    _cur_insn = pc;

    output()->bol();

    print_insn_labels();

  }

  void end_insn(address pc) {

    address pc0 = cur_insn();

    outputStream* st = output();

    if (_print_bytes && pc > pc0)

      print_insn_bytes(pc0, pc);

    if (_nm != NULL) {

      _nm->print_code_comment_on(st, COMMENT_COLUMN, pc0, pc);

      // this calls reloc_string_for which calls oop::print_value_on

    }

    print_hook_comments(pc0, _nm != NULL);

    // follow each complete insn by a nice newline

    st->cr();

  }

  address handle_event(const char* event, address arg);

  outputStream* output() { return _output; }

  address cur_insn() { return _cur_insn; }

  const char* options() { return _option_buf; }

  static void hook(const char* file, int line, address pc);

  void print_hook_comments(address pc, bool newline);

};

decode_env::SourceFileInfoTable decode_env::_src_table;

const char* decode_env::_cached_src = NULL;

GrowableArray<const char*>* decode_env::_cached_src_lines = NULL;

void decode_env::hook(const char* file, int line, address pc) {

  // For simplication, we never free from this table. It's really not

  // necessary as we add to the table only when PrintInterpreter is true,

  // which means we are debugging the VM and a little bit of extra

  // memory usage doesn't matter.

  SourceFileInfo* found = _src_table.get(pc);

  if (found != NULL) {

    found->append(file, line);

  } else {

    SourceFileInfo sfi(file, line);

    _src_table.put(pc, sfi); // sfi is copied by value

  }

}

void decode_env::print_hook_comments(address pc, bool newline) {

  SourceFileInfo* found = _src_table.get(pc);

  outputStream* st = output();

  if (found != NULL) {

    for (SourceFileInfo::Link *link = found->head; link; link = link->next) {

      const char* file = link->file;

      int line = link->line;

      if (_cached_src == NULL || strcmp(_cached_src, file) != 0) {

        FILE* fp;

        // _cached_src_lines is a single cache of the lines of a source file, and we refill this cache

        // every time we need to print a line from a different source file. It's not the fastest,

        // but seems bearable.

        if (_cached_src_lines != NULL) {

          for (int i=0; i<_cached_src_lines->length(); i++) {

            os::free((void*)_cached_src_lines->at(i));

          }

          _cached_src_lines->clear();

        } else {

          _cached_src_lines = new (ResourceObj::C_HEAP, mtCode)GrowableArray<const char*>(0, true);

        }

        if ((fp = fopen(file, "r")) == NULL) {

          _cached_src = NULL;

          return;

        }

        _cached_src = file;

        char line[500]; // don't write lines that are too long in your source files!

        while (fgets(line, sizeof(line), fp) != NULL) {

          size_t len = strlen(line);

          if (len > 0 && line[len-1] == '\n') {

            line[len-1] = '\0';

          }

          _cached_src_lines->append(os::strdup(line));

        }

        fclose(fp);

        _print_file_name = true;

      }

      if (_print_file_name) {

        // We print the file name whenever we switch to a new file, or when

        // Disassembler::decode is called to disassemble a new block of code.

        _print_file_name = false;

        if (newline) {

          st->cr();

        }

        st->move_to(COMMENT_COLUMN);

        st->print(";;@FILE: %s", file);

        newline = true;

      }

      int index = line - 1; // 1-based line number -> 0-based index.

      if (index >= _cached_src_lines->length()) {

        // This could happen if source file is mismatched.

      } else {

        const char* source_line = _cached_src_lines->at(index);

        if (newline) {

          st->cr();

        }

        st->move_to(COMMENT_COLUMN);

        st->print(";;%5d: %s", line, source_line);

        newline = true;

      }

    }

  }

}

decode_env::decode_env(CodeBlob* code, outputStream* output, CodeStrings c,

                       ptrdiff_t offset) {

  memset(this, 0, sizeof(*this)); // Beware, this zeroes bits of fields.

  _output = output ? output : tty;

  _code = code;

  if (code != NULL && code->is_nmethod())

    _nm = (nmethod*) code;

  _strings.copy(c);

  _offset = offset;

  // by default, output pc but not bytes:

  _print_pc       = true;

  _print_bytes    = false;

  _bytes_per_line = Disassembler::pd_instruction_alignment();

  _print_file_name= true;

  // parse the global option string:

  collect_options(Disassembler::pd_cpu_opts());

  collect_options(PrintAssemblyOptions);

  if (strstr(options(), "hsdis-")) {

    if (strstr(options(), "hsdis-print-raw"))

      _print_raw = (strstr(options(), "xml") ? 2 : 1);

    if (strstr(options(), "hsdis-print-pc"))

      _print_pc = !_print_pc;

    if (strstr(options(), "hsdis-print-bytes"))

      _print_bytes = !_print_bytes;

  }

  if (strstr(options(), "help")) {

    tty->print_cr("PrintAssemblyOptions help:");

    tty->print_cr("  hsdis-print-raw       test plugin by requesting raw output");

    tty->print_cr("  hsdis-print-raw-xml   test plugin by requesting raw xml");

    tty->print_cr("  hsdis-print-pc        turn off PC printing (on by default)");

    tty->print_cr("  hsdis-print-bytes     turn on instruction byte output");

    tty->print_cr("combined options: %s", options());

  }

}

address decode_env::handle_event(const char* event, address arg) {

  if (match(event, "insn")) {

    start_insn(arg);

  } else if (match(event, "/insn")) {

    end_insn(arg);

  } else if (match(event, "addr")) {

    if (arg != NULL) {

      print_address(arg);

      return arg;

    }

  } else if (match(event, "mach")) {

    static char buffer[32] = { 0, };

    if (strcmp(buffer, (const char*)arg) != 0 ||

        strlen((const char*)arg) > sizeof(buffer) - 1) {

      // Only print this when the mach changes

      strncpy(buffer, (const char*)arg, sizeof(buffer) - 1);

      buffer[sizeof(buffer) - 1] = '\0';

      output()->print_cr("[Disassembling for mach='%s']", arg);

    }

  } else if (match(event, "format bytes-per-line")) {

    _bytes_per_line = (int) (intptr_t) arg;

  } else {

    // ignore unrecognized markup

  }

  return NULL;

}

// called by the disassembler to print out jump targets and data addresses

void decode_env::print_address(address adr) {

  outputStream* st = _output;

  if (adr == NULL) {

    st->print("NULL");

    return;

  }

  int small_num = (int)(intptr_t)adr;

  if ((intptr_t)adr == (intptr_t)small_num

      && -1 <= small_num && small_num <= 9) {

    st->print("%d", small_num);

    return;

  }

  if (Universe::is_fully_initialized()) {

    if (StubRoutines::contains(adr)) {

      StubCodeDesc* desc = StubCodeDesc::desc_for(adr);

      if (desc == NULL) {

        desc = StubCodeDesc::desc_for(adr + frame::pc_return_offset);

      }

      if (desc != NULL) {

        st->print("Stub::%s", desc->name());

        if (desc->begin() != adr) {

          st->print(INTX_FORMAT_W(+) " " PTR_FORMAT, adr - desc->begin(), p2i(adr));

        } else if (WizardMode) {

          st->print(" " PTR_FORMAT, p2i(adr));

        }

        return;

      }

      st->print("Stub::<unknown> " PTR_FORMAT, p2i(adr));

      return;

    }

    BarrierSet* bs = BarrierSet::barrier_set();

    if (bs->is_a(BarrierSet::CardTableBarrierSet) &&

        adr == ci_card_table_address_as<address>()) {

      st->print("word_map_base");

      if (WizardMode) st->print(" " INTPTR_FORMAT, p2i(adr));

      return;

    }

  }

  if (_nm == NULL) {

    // Don't do this for native methods, as the function name will be printed in

    // nmethod::reloc_string_for().

    ResourceMark rm;

    const int buflen = 1024;

    char* buf = NEW_RESOURCE_ARRAY(char, buflen);

    int offset;

    if (os::dll_address_to_function_name(adr, buf, buflen, &offset)) {

      st->print(PTR_FORMAT " = %s",  p2i(adr), buf);

      if (offset != 0) {

        st->print("+%d", offset);

      }

      return;

    }

  }

  // Fall through to a simple (hexadecimal) numeral.

  st->print(PTR_FORMAT, p2i(adr));

}

void decode_env::print_insn_labels() {

  address p = cur_insn();

  outputStream* st = output();

  CodeBlob* cb = _code;

  if (cb != NULL) {

    cb->print_block_comment(st, p);

  }

  _strings.print_block_comment(st, (intptr_t)(p - _start + _offset));

  if (_print_pc) {

    st->print("  " PTR_FORMAT ": ", p2i(p));

  }

}