Merge branch 'master' into merge-job

[deliverable/binutils-gdb.git] / gdb / amdgcn-rocm-tdep.c

/* Target-dependent code for the ROCm amdgcn architecture.

   Copyright (C) 2019 Free Software Foundation, Inc.
   Copyright (C) 2019 Advanced Micro Devices, Inc. All rights reserved.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This 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 program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "amdgcn-rocm-tdep.h"
#include "arch-utils.h"
#include "dwarf2-frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
#include "gdbarch.h"
#include "inferior.h"
#include "osabi.h"
#include "reggroups.h"
#include "rocm-tdep.h"

bool
rocm_is_amdgcn_gdbarch (struct gdbarch *arch)
{
  return (gdbarch_bfd_arch_info (arch)->arch == bfd_arch_amdgcn);
}

/* Return the name of register REGNUM.  */
static const char *
amdgcn_register_name (struct gdbarch *gdbarch, int regnum)
{
  amd_dbgapi_process_id_t process_id = get_amd_dbgapi_process_id ();
  amd_dbgapi_wave_id_t wave_id = get_amd_dbgapi_wave_id (inferior_ptid);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  amd_dbgapi_size_t unused;
  if (amd_dbgapi_wave_register_get_info (
          process_id, wave_id, tdep->register_ids[regnum],
          AMD_DBGAPI_REGISTER_INFO_SIZE, sizeof (unused), &unused)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return "";

  return tdep->register_names[regnum].c_str ();
}

static int
amdgcn_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
{
  amd_dbgapi_architecture_id_t architecture_id;
  amd_dbgapi_register_id_t register_id;

  if (amd_dbgapi_get_architecture (gdbarch_bfd_arch_info (gdbarch)->mach,
                                   &architecture_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return -1;

  if (amd_dbgapi_dwarf_register_to_register (architecture_id, reg,
                                             &register_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return -1;

  return gdbarch_tdep (gdbarch)->regnum_map[register_id];
}

static struct type *
gdb_type_from_type_name (struct gdbarch *gdbarch, const std::string &type_name)
{
  size_t pos;

  /* vector types.  */
  if ((pos = type_name.find_last_of ('[')) != std::string::npos)
    {
      struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

      auto it = tdep->vector_type_map.find (type_name);
      if (it != tdep->vector_type_map.end ())
        return it->second;

      struct type *vector_type = init_vector_type (
          gdb_type_from_type_name (gdbarch, type_name.substr (0, pos)),
          std::stoi (type_name.substr (pos + 1)));

      tdep->vector_type_map[type_name] = vector_type;
      return vector_type;
    }
  /* scalar types.  */
  else if (type_name == "int32_t")
    return builtin_type (gdbarch)->builtin_int32;
  else if (type_name == "uint32_t")
    return builtin_type (gdbarch)->builtin_uint32;
  else if (type_name == "int64_t")
    return builtin_type (gdbarch)->builtin_int64;
  else if (type_name == "uint64_t")
    return builtin_type (gdbarch)->builtin_uint64;
  else if (type_name == "float")
    return builtin_type (gdbarch)->builtin_float;
  else if (type_name == "double")
    return builtin_type (gdbarch)->builtin_double;
  else if (type_name == "void (*)()")
    return builtin_type (gdbarch)->builtin_func_ptr;

  return builtin_type (gdbarch)->builtin_void;
}

static struct type *
amdgcn_register_type (struct gdbarch *gdbarch, int regnum)
{
  amd_dbgapi_process_id_t process_id = get_amd_dbgapi_process_id ();
  amd_dbgapi_wave_id_t wave_id = get_amd_dbgapi_wave_id (inferior_ptid);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  char *bytes;
  if (amd_dbgapi_wave_register_get_info (
          process_id, wave_id, tdep->register_ids[regnum],
          AMD_DBGAPI_REGISTER_INFO_TYPE, sizeof (bytes), &bytes)
      == AMD_DBGAPI_STATUS_SUCCESS)
    {
      std::string type_name (bytes);
      xfree (bytes);

      return gdb_type_from_type_name (gdbarch, type_name);
    }

  return builtin_type (gdbarch)->builtin_void;
}

static int
amdgcn_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
                            struct reggroup *group)
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  const char *name = reggroup_name (group);

  auto it = tdep->register_class_map.find (name);
  if (it == tdep->register_class_map.end ())
    return group == all_reggroup;

  amd_dbgapi_architecture_id_t architecture_id;

  if (amd_dbgapi_get_architecture (gdbarch_bfd_arch_info (gdbarch)->mach,
                                   &architecture_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return group == all_reggroup;

  amd_dbgapi_register_class_state_t state;

  if (amd_dbgapi_register_is_in_register_class (
          architecture_id, tdep->register_ids[regnum], it->second, &state)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return group == all_reggroup;

  return state == AMD_DBGAPI_REGISTER_CLASS_STATE_MEMBER
         || group == all_reggroup;
}

static int
amdgcn_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *)
{
  return gdbarch_tdep (gdbarch)->breakpoint_instruction_size;
}

static const gdb_byte *
amdgcn_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
{
  *size = kind;
  return gdbarch_tdep (gdbarch)->breakpoint_instruction_bytes.get ();
}

struct amdgcn_frame_cache
{
  CORE_ADDR base;
  CORE_ADDR pc;
};

static struct amdgcn_frame_cache *
amdgcn_frame_cache (struct frame_info *this_frame, void **this_cache)
{
  if (*this_cache)
    return (struct amdgcn_frame_cache *)*this_cache;

  struct amdgcn_frame_cache *cache
      = FRAME_OBSTACK_ZALLOC (struct amdgcn_frame_cache);
  (*this_cache) = cache;

  cache->pc = get_frame_func (this_frame);
  cache->base = 0;

  return cache;
}

static void
amdgcn_frame_this_id (struct frame_info *this_frame, void **this_cache,
                      struct frame_id *this_id)
{
  struct amdgcn_frame_cache *cache
      = amdgcn_frame_cache (this_frame, this_cache);

  if (get_frame_type (this_frame) == INLINE_FRAME)
    (*this_id) = frame_id_build (cache->base, cache->pc);
  else
    (*this_id) = outer_frame_id;

  if (frame_debug)
    {
      fprintf_unfiltered (
          gdb_stdlog, "{ amdgcn_frame_this_id (this_frame=%d) type=%d -> ",
          frame_relative_level (this_frame), get_frame_type (this_frame));
      fprint_frame_id (gdb_stdlog, *this_id);
      fprintf_unfiltered (gdb_stdlog, "}\n");
    }

  return;
}

static struct frame_id
amdgcn_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
  return frame_id_build (0, get_frame_pc (this_frame));
}

static struct value *
amdgcn_frame_prev_register (struct frame_info *this_frame, void **this_cache,
                            int regnum)
{
  return frame_unwind_got_register (this_frame, regnum, regnum);
}

static const struct frame_unwind amdgcn_frame_unwind = {
  NORMAL_FRAME,
  default_frame_unwind_stop_reason,
  amdgcn_frame_this_id,
  amdgcn_frame_prev_register,
  NULL,
  default_frame_sniffer,
  NULL,
  NULL,
};

struct rocm_displaced_step_closure : public displaced_step_closure
{
  amd_dbgapi_process_id_t process_id;
  amd_dbgapi_wave_id_t wave_id;
  amd_dbgapi_displaced_stepping_id_t displaced_stepping_id;
};

static CORE_ADDR
amdgcn_rocm_displaced_step_location (struct gdbarch *gdbarch)
{
  size_t size = gdbarch_tdep (gdbarch)->breakpoint_instruction_size;
  gdb::unique_xmalloc_ptr<gdb_byte> buffer (
      static_cast<gdb_byte *> (xmalloc (size)));

  /* Read the bytes that were overwritten by the breakpoint instruction.  */
  if (target_read_memory (regcache_read_pc (get_current_regcache ()),
                          buffer.get (), size))
    return 0;

  amd_dbgapi_displaced_stepping_id_t stepping_id;
  if (amd_dbgapi_displaced_stepping_start (
          get_amd_dbgapi_process_id (), get_amd_dbgapi_wave_id (inferior_ptid),
          buffer.get (), &stepping_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return 0;

  return stepping_id.handle;
}

static struct displaced_step_closure *
amdgcn_rocm_displaced_step_copy_insn (struct gdbarch *gdbarch, CORE_ADDR from,
                                      CORE_ADDR to, struct regcache *regcache)
{
  rocm_displaced_step_closure *closure = new rocm_displaced_step_closure;

  closure->process_id = get_amd_dbgapi_process_id ();
  closure->wave_id = get_amd_dbgapi_wave_id (inferior_ptid);
  closure->displaced_stepping_id = { to };

  return closure;
}

static void
amdgcn_rocm_displaced_step_fixup (struct gdbarch *gdbarch,
                                  struct displaced_step_closure *closure_,
                                  CORE_ADDR from, CORE_ADDR to,
                                  struct regcache *regcache)
{
  rocm_displaced_step_closure *closure
      = reinterpret_cast<rocm_displaced_step_closure *> (closure_);

  amd_dbgapi_status_t status = amd_dbgapi_displaced_stepping_complete (
      closure->process_id, closure->wave_id, closure->displaced_stepping_id);

  if (status != AMD_DBGAPI_STATUS_SUCCESS)
    error (_ ("amd_dbgapi_displaced_stepping_complete failed (rc=%d"), status);

  /* We may have written some registers, so flush the register cache.  */
  registers_changed_ptid (regcache->ptid ());
}

static int
print_insn_amdgcn (bfd_vma memaddr, struct disassemble_info *di)
{
  gdb_disassembler *self
      = static_cast<gdb_disassembler *> (di->application_data);

  /* Try to read at most instruction_size bytes.  */

  amd_dbgapi_size_t instruction_size = gdbarch_max_insn_length (self->arch ());
  gdb::unique_xmalloc_ptr<gdb_byte> buffer (
      (gdb_byte *)xmalloc (instruction_size));

  instruction_size
      = target_read (current_top_target (), TARGET_OBJECT_MEMORY, NULL,
                     buffer.get (), memaddr, instruction_size);
  if (!instruction_size)
    {
      (*di->memory_error_func) (-1, memaddr, di);
      return -1;
    }

  amd_dbgapi_architecture_id_t architecture_id;
  if (amd_dbgapi_get_architecture (gdbarch_bfd_arch_info (self->arch ())->mach,
                                   &architecture_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return -1;

  char *instruction_text = nullptr;
  amd_dbgapi_global_address_t *operands = nullptr;
  amd_dbgapi_size_t operand_count = 0;

  if (amd_dbgapi_disassemble_instruction (
          architecture_id, static_cast<amd_dbgapi_global_address_t> (memaddr),
          &instruction_size, buffer.get (), &instruction_text, &operand_count,
          &operands)
      != AMD_DBGAPI_STATUS_SUCCESS)
    {
      size_t alignment;
      if (amd_dbgapi_architecture_get_info (
              architecture_id,
              AMD_DBGAPI_ARCHITECTURE_INFO_MINIMUM_INSTRUCTION_ALIGNMENT,
              sizeof (alignment), &alignment)
          != AMD_DBGAPI_STATUS_SUCCESS)
        error (_ ("amd_dbgapi_architecture_get_info failed"));

      (*di->fprintf_func) (di->stream, "<illegal instruction>");
      /* Skip to the next valid instruction address.  */
      return align_up (memaddr + 1, alignment) - memaddr;
    }

  /* Print the instruction.  */
  (*di->fprintf_func) (di->stream, "%s", instruction_text);

  /* Print the operands.  */
  for (size_t i = 0; i < operand_count; ++i)
    {
      (*di->fprintf_func) (di->stream, (i == 0) ? "  # " : ", ");
      (*di->print_address_func) (static_cast<bfd_vma> (operands[i]), di);
    }

  /* Free the memory allocated by the amd-dbgapi.  */
  xfree (instruction_text);
  xfree (operands);

  return static_cast<int> (instruction_size);
}

static CORE_ADDR
amdgcn_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
{
  CORE_ADDR func_addr;

  /* See if we can determine the end of the prologue via the symbol table.
     If so, then return either PC, or the PC after the prologue, whichever
     is greater.  */
  if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
    {
      CORE_ADDR post_prologue_pc
          = skip_prologue_using_sal (gdbarch, func_addr);
      struct compunit_symtab *cust = find_pc_compunit_symtab (func_addr);

      /* Clang always emits a line note before the prologue and another
         one after.  We trust clang to emit usable line notes.  */
      if (post_prologue_pc
          && (cust != NULL && COMPUNIT_PRODUCER (cust) != NULL
              && startswith (COMPUNIT_PRODUCER (cust), "clang ")))
        return std::max (start_pc, post_prologue_pc);
    }

  /* Can't determine prologue from the symbol table, need to examine
     instructions.  */

  return start_pc;
}

static struct gdbarch *
amdgcn_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
  /* If there is already a candidate, use it.  */
  arches = gdbarch_list_lookup_by_info (arches, &info);
  if (arches != NULL)
    return arches->gdbarch;

  struct gdbarch_deleter
  {
    void
    operator() (struct gdbarch *gdbarch) const
    {
      gdbarch_free (gdbarch);
    }
  };

  /* Allocate space for the new architecture.  */
  std::unique_ptr<struct gdbarch_tdep> tdep (new struct gdbarch_tdep);
  std::unique_ptr<struct gdbarch, gdbarch_deleter> gdbarch_u (
      gdbarch_alloc (&info, tdep.get ()));

  struct gdbarch *gdbarch = gdbarch_u.get ();

  /* Data types.  */
  set_gdbarch_char_signed (gdbarch, 0);
  set_gdbarch_ptr_bit (gdbarch, 64);
  set_gdbarch_addr_bit (gdbarch, 64);
  set_gdbarch_short_bit (gdbarch, 16);
  set_gdbarch_int_bit (gdbarch, 32);
  set_gdbarch_long_bit (gdbarch, 64);
  set_gdbarch_long_long_bit (gdbarch, 64);
  set_gdbarch_float_bit (gdbarch, 32);
  set_gdbarch_double_bit (gdbarch, 64);
  set_gdbarch_long_double_bit (gdbarch, 128);
  set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
  set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
  set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);

  /* Frame Interpretation.  */
  set_gdbarch_skip_prologue (gdbarch, amdgcn_skip_prologue);
  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
  dwarf2_append_unwinders (gdbarch);
  frame_unwind_append_unwinder (gdbarch, &amdgcn_frame_unwind);
  set_gdbarch_dummy_id (gdbarch, amdgcn_dummy_id);

  /* Registers and Memory.  */
  amd_dbgapi_architecture_id_t architecture_id;
  if (amd_dbgapi_get_architecture (gdbarch_bfd_arch_info (gdbarch)->mach,
                                   &architecture_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return nullptr;

  size_t register_class_count;
  amd_dbgapi_register_class_id_t *register_class_ids;

  if (amd_dbgapi_architecture_register_class_list (
          architecture_id, &register_class_count, &register_class_ids)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return nullptr;

  /* Add register groups.  */
  reggroup_add (gdbarch, all_reggroup);

  for (size_t i = 0; i < register_class_count; ++i)
    {
      char *bytes;
      if (amd_dbgapi_architecture_register_class_get_info (
              architecture_id, register_class_ids[i],
              AMD_DBGAPI_REGISTER_CLASS_INFO_NAME, sizeof (bytes), &bytes)
          != AMD_DBGAPI_STATUS_SUCCESS)
        continue;

      gdb::unique_xmalloc_ptr<char> name (bytes);

      auto inserted = tdep->register_class_map.emplace (name.get (),
                                                        register_class_ids[i]);

      if (!inserted.second)
        continue;

      /* Allocate the reggroup in the gdbarch.  */
      auto *group = reggroup_gdbarch_new (gdbarch, name.get (), USER_REGGROUP);
      if (!group)
        {
          tdep->register_class_map.erase (inserted.first);
          continue;
        }

      reggroup_add (gdbarch, group);
    }
  xfree (register_class_ids);

  /* Add registers. */
  size_t register_count;
  amd_dbgapi_register_id_t *register_ids;

  if (amd_dbgapi_architecture_register_list (architecture_id, &register_count,
                                             &register_ids)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return nullptr;

  tdep->register_ids.insert (tdep->register_ids.end (), &register_ids[0],
                             &register_ids[register_count]);

  set_gdbarch_num_regs (gdbarch, register_count);
  set_gdbarch_num_pseudo_regs (gdbarch, 0);
  xfree (register_ids);

  tdep->register_names.resize (register_count);
  for (size_t i = 0; i < register_count; ++i)
    {
      if (!tdep->regnum_map.emplace (tdep->register_ids[i], i).second)
        return nullptr;

      char *bytes;
      if (amd_dbgapi_architecture_register_get_info (
              architecture_id, tdep->register_ids[i],
              AMD_DBGAPI_REGISTER_INFO_NAME, sizeof (bytes), &bytes)
          != AMD_DBGAPI_STATUS_SUCCESS)
        continue;

      tdep->register_names[i] = bytes;
      xfree (bytes);
    }

  amd_dbgapi_register_id_t pc_register_id;
  if (amd_dbgapi_architecture_get_info (
          architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_PC_REGISTER,
          sizeof (pc_register_id), &pc_register_id)
      != AMD_DBGAPI_STATUS_SUCCESS)
    return nullptr;

  set_gdbarch_pc_regnum (gdbarch, tdep->regnum_map[pc_register_id]);
  set_gdbarch_ps_regnum (gdbarch, -1);
  set_gdbarch_sp_regnum (gdbarch, -1);
  set_gdbarch_fp0_regnum (gdbarch, -1);

  set_gdbarch_dwarf2_reg_to_regnum (gdbarch, amdgcn_dwarf_reg_to_regnum);

  /* Register Representation.  */
  set_gdbarch_register_name (gdbarch, amdgcn_register_name);
  set_gdbarch_register_type (gdbarch, amdgcn_register_type);
  set_gdbarch_register_reggroup_p (gdbarch, amdgcn_register_reggroup_p);

  /* Disassembly.  */
  set_gdbarch_print_insn (gdbarch, print_insn_amdgcn);

  /* Displaced stepping.  */
  set_gdbarch_displaced_step_location (gdbarch,
                                       amdgcn_rocm_displaced_step_location);

  set_gdbarch_displaced_step_copy_insn (gdbarch,
                                        amdgcn_rocm_displaced_step_copy_insn);
  set_gdbarch_displaced_step_fixup (gdbarch, amdgcn_rocm_displaced_step_fixup);

  /* Instructions.  */
  amd_dbgapi_size_t max_insn_length = 0;
  if (amd_dbgapi_architecture_get_info (
          architecture_id,
          AMD_DBGAPI_ARCHITECTURE_INFO_LARGEST_INSTRUCTION_SIZE,
          sizeof (max_insn_length), &max_insn_length)
      != AMD_DBGAPI_STATUS_SUCCESS)
    error (_ ("amd_dbgapi_architecture_get_info failed"));

  set_gdbarch_max_insn_length (gdbarch, max_insn_length);

  if (amd_dbgapi_architecture_get_info (
          architecture_id,
          AMD_DBGAPI_ARCHITECTURE_INFO_BREAKPOINT_INSTRUCTION_SIZE,
          sizeof (tdep->breakpoint_instruction_size),
          &tdep->breakpoint_instruction_size)
      != AMD_DBGAPI_STATUS_SUCCESS)
    error (_ ("amd_dbgapi_architecture_get_info failed"));

  gdb_byte *breakpoint_instruction_bytes;
  if (amd_dbgapi_architecture_get_info (
          architecture_id, AMD_DBGAPI_ARCHITECTURE_INFO_BREAKPOINT_INSTRUCTION,
          sizeof (breakpoint_instruction_bytes),
          &breakpoint_instruction_bytes)
      != AMD_DBGAPI_STATUS_SUCCESS)
    error (_ ("amd_dbgapi_architecture_get_info failed"));

  tdep->breakpoint_instruction_bytes.reset (breakpoint_instruction_bytes);

  set_gdbarch_breakpoint_kind_from_pc (gdbarch,
                                       amdgcn_breakpoint_kind_from_pc);
  set_gdbarch_sw_breakpoint_from_kind (gdbarch,
                                       amdgcn_sw_breakpoint_from_kind);

  tdep.release ();
  gdbarch_u.release ();

  return gdbarch;
}

/* Provide a prototype to silence -Wmissing-prototypes.  */
extern initialize_file_ftype _initialize_amdgcn_rocm_tdep;

void
_initialize_amdgcn_rocm_tdep (void)
{
  gdbarch_register (bfd_arch_amdgcn, amdgcn_gdbarch_init, NULL);
}