Quelle  hsdis-llvm.cpp

/*
 * Copyright (c) 2008, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * The Universal Permissive License (UPL), Version 1.0
 *
 * Subject to the condition set forth below, permission is hereby granted to
 * any person obtaining a copy of this software, associated documentation
 * and/or data (collectively the "Software"), free of charge and under any
 * and all copyright rights in the Software, and any and all patent rights
 * owned or freely licensable by each licensor hereunder covering either (i)
 * the unmodified Software as contributed to or provided by such licensor,
 * or (ii) the Larger Works (as defined below), to deal in both
 *
 * (a) the Software, and
 *
 * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file
 * if one is included with the Software (each a "Larger Work" to which the
 * Software is contributed by such licensors),
 *
 * without restriction, including without limitation the rights to copy,
 * create derivative works of, display, perform, and distribute the Software
 * and make, use, sell, offer for sale, import, export, have made, and have
 * sold the Software and the Larger Work(s), and to sublicense the foregoing
 * rights on either these or other terms.
 *
 * This license is subject to the following condition:
 *
 * The above copyright notice and either this complete permission notice or
 * at a minimum a reference to the UPL must be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * 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.
 *
 */

/* hsdis.cpp -- dump a range of addresses as native instructions
   This implements the plugin protocol required by the
   HotSpot PrintAssembly option.
*/

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <inttypes.h>
#include <string.h>

#include <llvm-c/Disassembler.h>
#include <llvm-c/DisassemblerTypes.h>
#include <llvm-c/Target.h>
#include <llvm-c/TargetMachine.h>

#include "hsdis.h"

/* short names for stuff in hsdis.h */
typedef decode_instructions_event_callback_ftype  event_callback_t;
typedef decode_instructions_printf_callback_ftype printf_callback_t;

class hsdis_backend_base {
 protected:
  uintptr_t         _start_va;
  uintptr_t         _end_va;
  unsigned char*    _buffer;
  uintptr_t         _length;
  event_callback_t  _event_callback;
  void*             _event_stream;
  printf_callback_t _printf_callback;
  void*             _printf_stream;
  int               _do_newline;

  bool              _losing;
  const char*       _arch_name;

  virtual void print_help(const char* msg, const char* arg) = 0;
  virtual void print_insns_config() = 0;
  virtual size_t decode_instruction(uintptr_t p, uintptr_t start, uintptr_t end) = 0;
  virtual const char* format_insn_close(const char* close, char* buf, size_t bufsize) = 0;

 private:
  /* ignore all events, return a null */
  static void* null_event_callback(void* ignore_stream, const char* ignore_event, void* arg) {
    return NULL;
  }

  /* print all events as XML markup */
  static void* xml_event_callback(void* stream, const char* event, void* arg) {
    FILE* fp = (FILE*) stream;
#define NS_PFX "dis:"
    if (event[0] != '/') {
      /* issue the tag, with or without a formatted argument */
      fprintf(fp, "<" NS_PFX);
      fprintf(fp, event, arg);
      fprintf(fp, ">");
    } else {
      ++event;                    /* skip slash */
      const char* argp = strchr(event, ' ');
      if (argp == NULL) {
        /* no arguments; just issue the closing tag */
        fprintf(fp, "</" NS_PFX "%s>", event);
      } else {
        /* split out the closing attributes as <dis:foo_done attr='val'/> */
        size_t event_prefix =(argp - event);
        fprintf(fp, "<" NS_PFX "%.*s_done", (int) event_prefix, event);
        fprintf(fp, argp, arg);
        fprintf(fp, "/></" NS_PFX "%.*s>", (int) event_prefix, event);
      }
    }
#undef NS_PFX
    return NULL;
  }

protected:
  hsdis_backend_base(uintptr_t start_va, uintptr_t end_va,
                     unsigned char* buffer, uintptr_t length,
                     event_callback_t  event_callback,  void* event_stream,
                     printf_callback_t printf_callback, void* printf_stream,
                     int do_newline) :
      _start_va(start_va), _end_va(end_va),
      _buffer(buffer), _length(length),
      _event_callback(event_callback), _event_stream(event_stream),
      _printf_callback(printf_callback), _printf_stream(printf_stream),
      _do_newline(do_newline),
      _losing(false), _arch_name(NULL)
  {
    /* Make reasonable defaults for null callbacks.
      A non-null stream for a null callback is assumed to be a FILE* for output.
      Events are rendered as XML.
    */
    if (_printf_callback == NULL) {
      int (*fprintf_callback)(FILE*, const char*, ...) = &fprintf;
      FILE* fprintf_stream = stdout;
      _printf_callback = (printf_callback_t) fprintf_callback;
      if (_printf_stream == NULL)
        _printf_stream   = (void*)           fprintf_stream;
    }
    if (_event_callback == NULL) {
      if (_event_stream == NULL)
        _event_callback = (event_callback_t)&null_event_callback;
      else
        _event_callback = (event_callback_t)&xml_event_callback;
    }
  }

 public:
  void* decode() {
    uintptr_t start = _start_va;
    uintptr_t end   = _end_va;
    uintptr_t p     = start;

    (*_event_callback)(_event_stream, "insns", (void*)start);

    print_insns_config();

    while (p < end && !_losing) {
      (*_event_callback)(_event_stream, "insn", (void*) p);

      size_t size = decode_instruction(p, start, end);
      if (size > 0)  p += size;
      else           _losing = true;

      if (!_losing) {
        char buf[128];
        const char* insn_close = format_insn_close("/insn", buf, sizeof(buf));
        (*_event_callback)(_event_stream, insn_close, (void*) p);

        if (_do_newline) {
          /* follow each complete insn by a nice newline */
          (*_printf_callback)(_printf_stream, "\n");
        }
      }
    }

    if (_losing) (*_event_callback)(_event_stream, "/insns", (void*) p);
    return (void*) p;
  }
};


class hsdis_backend : public hsdis_backend_base {
 private:
  LLVMDisasmContextRef      _dcontext;
  char                      _target_triple[128];

  void parse_caller_options(const char* options) {
    memset(&_target_triple, 0, sizeof(_target_triple));
    const char* p;
    for (p = options; p != NULL; ) {
      const char* q = strchr(p, ',');
      size_t plen = (q == NULL) ? strlen(p) : ((q++) - p);
      if (plen == 4 && strncmp(p, "help", plen) == 0) {
        print_help(NULL, NULL);
      } else if (plen > 6 && strncmp(p, "hsdis-", 6) == 0) {
        // do not pass these to the next level
      } else if (plen >= 14 && strncmp(p, "target_triple=", 14) == 0) {
        char*  target_triple = _target_triple;
        size_t target_triple_size   = sizeof(_target_triple);
        target_triple_size -= 1;           /*leave room for the null*/
        if (plen > target_triple_size)  plen = target_triple_size;
        strncpy(target_triple, p, plen);
        target_triple[plen] = '\0';
      }
      p = q;
    }
  }

  const char* native_target_triple() {
    return LLVM_DEFAULT_TRIPLET;
  }

 public:
  hsdis_backend(uintptr_t start_va, uintptr_t end_va,
                unsigned char* buffer, uintptr_t length,
                event_callback_t  event_callback,  void* event_stream,
                printf_callback_t printf_callback, void* printf_stream,
                const char* options, int newline)
    : hsdis_backend_base(start_va, end_va,
                         buffer, length,
                         event_callback, event_stream,
                         printf_callback, printf_stream,
                         newline),
      _dcontext(NULL) {
    /* Look into _options for anything interesting. */
    if (options != NULL)
      parse_caller_options(options);

    /* Discover which architecture we are going to disassemble. */
    _arch_name = &_target_triple[0];
    if (_arch_name[0] == '\0')
      _arch_name = native_target_triple();

    if (LLVMInitializeNativeTarget() != 0) {
      static bool complained = false;
      if (!complained)
        (*_printf_callback)(_printf_stream, "failed to initialize LLVM native target\n");
      complained = true;
      /* must bail out */
      _losing = true;
      return;
    }
    if (LLVMInitializeNativeAsmPrinter() != 0) {
      static bool complained = false;
      if (!complained)
        (*_printf_callback)(_printf_stream, "failed to initialize LLVM native asm printer\n");
      complained = true;
      /* must bail out */
      _losing = true;
      return;
    }
    if (LLVMInitializeNativeDisassembler() != 0) {
      static bool complained = false;
      if (!complained)
        (*_printf_callback)(_printf_stream, "failed to initialize LLVM native disassembler\n");
      complained = true;
      /* must bail out */
      _losing = true;
      return;
    }
    if ((_dcontext = LLVMCreateDisasm(_arch_name, NULL, 0, NULL, NULL)) == NULL) {
      static bool complained = false;
      const char* bad = _arch_name;
      if (bad == &_target_triple[0])
        print_help("bad target_triple=%s", bad);
      else if (!complained)
        print_help("bad native target_triple=%s; please port hsdis to this platform", bad);
      complained = true;
      /* must bail out */
      _losing = true;
      return;
    }

    LLVMSetDisasmOptions(_dcontext, LLVMDisassembler_Option_PrintImmHex);
  }

  ~hsdis_backend() {
    if (_dcontext != NULL) {
      LLVMDisasmDispose(_dcontext);
    }
  }

 protected:
  virtual void print_help(const char* msg, const char* arg) {
    if (msg != NULL) {
      (*_printf_callback)(_printf_stream, "hsdis: ");
      (*_printf_callback)(_printf_stream, msg, arg);
      (*_printf_callback)(_printf_stream, "\n");
    }
    (*_printf_callback)(_printf_stream, "hsdis output options:\n");
    (*_printf_callback)(_printf_stream, "  target_triple=<triple> select disassembly target\n");
    (*_printf_callback)(_printf_stream, "  help          print this message\n");
  }

  virtual void print_insns_config() {
    (*_event_callback)(_event_stream, "target_triple name='%s'",
                      (void*) _arch_name);
  }

  virtual size_t decode_instruction(uintptr_t p, uintptr_t start, uintptr_t end) {
    char buf[128];
    size_t size = LLVMDisasmInstruction(_dcontext, (uint8_t*)p, (uint64_t)(end - start), (uint64_t)p, buf, sizeof(buf));
    if (size > 0) {
      (*_printf_callback)(_printf_stream, "%s", buf);
    } else {
      // LLVM encountered an unknown instruction
      if (end - start >= 4) {
        // Print the following word and skip past it
        snprintf(buf, sizeof(buf), "\t.inst\t#0x%08x ; undefined", *(uint32_t*)p);
        size = 4;
      } else {
        snprintf(buf, sizeof(buf), "\t<invalid instruction, aborting hsdis>");
      }
    }
    return size;
  }

  virtual const char* format_insn_close(const char* close, char* buf, size_t bufsize) {
    return close;
  }
};


void* decode_instructions_virtual(uintptr_t start_va, uintptr_t end_va,
                            unsigned char* buffer, uintptr_t length,
                            event_callback_t  event_callback_arg,  void* event_stream_arg,
                            printf_callback_t printf_callback_arg, void* printf_stream_arg,
                            const char* options, int newline) {
  return hsdis_backend(start_va, end_va,
                       buffer, length,
                       event_callback_arg, event_stream_arg,
                       printf_callback_arg, printf_stream_arg,
                       options, newline == 0 ? false : true)
          .decode();
}

/* This is the compatability interface for older version of hotspot */
void* decode_instructions(void* start_pv, void* end_pv,
                    event_callback_t  event_callback_arg,  void* event_stream_arg,
                    printf_callback_t printf_callback_arg, void* printf_stream_arg,
                    const char* options) {
  return decode_instructions_virtual((uintptr_t)start_pv,
                                     (uintptr_t)end_pv,
                                     (unsigned char*)start_pv,
                                     (uintptr_t)end_pv - (uintptr_t)start_pv,
                                     event_callback_arg,
                                     event_stream_arg,
                                     printf_callback_arg,
                                     printf_stream_arg,
                                     options, false);
}