/*
 * Copyright (c) 2019, 2024, 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.c -- dump a range of addresses as native instructions
   This implements the plugin protocol required by the
   HotSpot PrintAssembly option.
*/

#include <inttypes.h>
#include <string.h>

/* Undefine macro to avoid generating invalid C code.
   Capstone refactored cs_detail for AArch64 architecture
   from `cs_arm64 arm64` to `cs_aarch64 aarch64`
   and that causes invalid macro expansion.
*/
#undef aarch64
#include <capstone.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;

#define print(...) (*printf_callback) (printf_stream, __VA_ARGS__)

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 */
    fprintf(fp, "</"NS_PFX"%s>", event);
  }
  return NULL;
}

static const char* INTEL_SYNTAX_OP = "intel";

typedef struct {
  bool intel_syntax;
} Options;

static Options parse_options(const char* options, printf_callback_t printf_callback, void* printf_stream) {
  Options ops;
  // initialize with defaults
  ops.intel_syntax = false;

  const char* cursor = options;
  while (*cursor != '\0') {
    if (*cursor == ',') {
      cursor++;
    }
    if (strncmp(cursor, INTEL_SYNTAX_OP, strlen(INTEL_SYNTAX_OP)) == 0) {
      cursor += strlen(INTEL_SYNTAX_OP);
      ops.intel_syntax = true;
    } else {
      const char* end = strchr(cursor, ',');
      if (end == NULL) {
        end = strchr(cursor, '\0');
      }
      print("Unknown PrintAssembly option: %.*s\n", (int) (end - cursor), cursor);
      cursor = end;
    }
  }

  return ops;
}

JNIEXPORT
void* decode_instructions_virtual(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 /* bool value for nice new line */) {
  csh cs_handle;

  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 = &null_event_callback;
    else
      event_callback = &xml_event_callback;
  }


  if (cs_open(CAPSTONE_ARCH, CAPSTONE_MODE, &cs_handle) != CS_ERR_OK) {
    print("Could not open cs_handle");
    return NULL;
  }

  Options ops = parse_options(options, printf_callback, printf_stream);
  cs_option(cs_handle, CS_OPT_SYNTAX, ops.intel_syntax ? CS_OPT_SYNTAX_INTEL : CS_OPT_SYNTAX_ATT);

  // Turn on SKIPDATA mode to skip broken instructions. HotSpot often
  // has embedded data in method bodies, and we need disassembly to
  // continue when such non-instructions are not recognized.
  cs_option(cs_handle, CS_OPT_SKIPDATA, CS_OPT_ON);

  cs_insn *insn;
  size_t count = cs_disasm(cs_handle, buffer, length, (uintptr_t) buffer, 0 , &insn);
  if (count) {
    for (unsigned int j = 0; j < count; j++) {
      (*event_callback)(event_stream, "insn", (void*) insn[j].address);
      print("%s\t\t%s", insn[j].mnemonic, insn[j].op_str);
      (*event_callback)(event_stream, "/insn", (void*) (insn[j].address + insn[j].size));
      if (newline) {
        /* follow each complete insn by a nice newline */
        print("\n");
      }
    }
    cs_free(insn, count);
  }

  cs_close(&cs_handle);

  return NULL;
}
