//===-- DWARFASTParserJava.cpp ----------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "DWARFASTParserJava.h"
#include "DWARFAttribute.h"
#include "DWARFUnit.h"
#include "DWARFDebugInfoEntry.h"
#include "DWARFDebugInfoEntry.h"
#include "DWARFDeclContext.h"
#include "SymbolFileDWARF.h"

#include "lldb/Core/Module.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/TypeList.h"

using namespace lldb;
using namespace lldb_private;

DWARFASTParserJava::DWARFASTParserJava(JavaASTContext &ast) : m_ast(ast) {}

DWARFASTParserJava::~DWARFASTParserJava() {}

TypeSP DWARFASTParserJava::ParseBaseTypeFromDIE(const DWARFDIE &die) {
  SymbolFileDWARF *dwarf = die.GetDWARF();
  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

  ConstString type_name;
  uint64_t byte_size = 0;

  DWARFAttributes attributes;
  const size_t num_attributes = die.GetAttributes(attributes);
  for (uint32_t i = 0; i < num_attributes; ++i) {
    DWARFFormValue form_value;
    dw_attr_t attr = attributes.AttributeAtIndex(i);
    if (attributes.ExtractFormValueAtIndex(i, form_value)) {
      switch (attr) {
      case DW_AT_name:
        type_name.SetCString(form_value.AsCString());
        break;
      case DW_AT_byte_size:
        byte_size = form_value.Unsigned();
        break;
      case DW_AT_encoding:
        break;
      default:
        assert(false && "Unsupported attribute for DW_TAG_base_type");
      }
    }
  }

  Declaration decl;
  CompilerType compiler_type = m_ast.CreateBaseType(type_name);
  return std::make_shared<Type>(die.GetID(), dwarf, type_name, byte_size,
                                nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
                                decl, compiler_type, Type::eResolveStateFull);
}

TypeSP DWARFASTParserJava::ParseArrayTypeFromDIE(const DWARFDIE &die) {
  SymbolFileDWARF *dwarf = die.GetDWARF();
  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

  ConstString linkage_name;
  DWARFFormValue type_attr_value;
  lldb::addr_t data_offset = LLDB_INVALID_ADDRESS;
  DWARFExpression length_expression(die.GetCU());

  DWARFAttributes attributes;
  const size_t num_attributes = die.GetAttributes(attributes);
  for (uint32_t i = 0; i < num_attributes; ++i) {
    DWARFFormValue form_value;
    dw_attr_t attr = attributes.AttributeAtIndex(i);
    if (attributes.ExtractFormValueAtIndex(i, form_value)) {
      switch (attr) {
      case DW_AT_linkage_name:
        linkage_name.SetCString(form_value.AsCString());
        break;
      case DW_AT_type:
        type_attr_value = form_value;
        break;
      case DW_AT_data_member_location:
        data_offset = form_value.Unsigned();
        break;
      case DW_AT_declaration:
        break;
      default:
        assert(false && "Unsupported attribute for DW_TAG_array_type");
      }
    }
  }

  for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
       child_die = child_die.GetSibling()) {
    if (child_die.Tag() == DW_TAG_subrange_type) {
      DWARFAttributes attributes;
      const size_t num_attributes = child_die.GetAttributes(attributes);
      for (uint32_t i = 0; i < num_attributes; ++i) {
        DWARFFormValue form_value;
        dw_attr_t attr = attributes.AttributeAtIndex(i);
        if (attributes.ExtractFormValueAtIndex(i, form_value)) {
          switch (attr) {
          case DW_AT_count:
            if (form_value.BlockData())
              length_expression.CopyOpcodeData(
                  form_value.BlockData(), form_value.Unsigned(),
                  child_die.GetCU()->GetByteOrder(),
                  child_die.GetCU()->GetAddressByteSize());
            break;
          default:
            assert(false && "Unsupported attribute for DW_TAG_subrange_type");
          }
        }
      }
    } else {
      assert(false && "Unsupported child for DW_TAG_array_type");
    }
  }

  DIERef type_die_ref(type_attr_value);
  Type *element_type = dwarf->ResolveTypeUID(type_die_ref);
  if (!element_type)
    return nullptr;

  CompilerType element_compiler_type = element_type->GetForwardCompilerType();
  CompilerType array_compiler_type = m_ast.CreateArrayType(
      linkage_name, element_compiler_type, length_expression, data_offset);

  Declaration decl;
  TypeSP type_sp(new Type(die.GetID(), dwarf, array_compiler_type.GetTypeName(),
                          -1, nullptr, type_die_ref.GetUID(dwarf),
                          Type::eEncodingIsUID, &decl, array_compiler_type,
                          Type::eResolveStateFull));
  type_sp->SetEncodingType(element_type);
  return type_sp;
}

TypeSP DWARFASTParserJava::ParseReferenceTypeFromDIE(const DWARFDIE &die) {
  SymbolFileDWARF *dwarf = die.GetDWARF();
  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

  Declaration decl;
  DWARFFormValue type_attr_value;

  DWARFAttributes attributes;
  const size_t num_attributes = die.GetAttributes(attributes);
  for (uint32_t i = 0; i < num_attributes; ++i) {
    DWARFFormValue form_value;
    dw_attr_t attr = attributes.AttributeAtIndex(i);
    if (attributes.ExtractFormValueAtIndex(i, form_value)) {
      switch (attr) {
      case DW_AT_type:
        type_attr_value = form_value;
        break;
      default:
        assert(false && "Unsupported attribute for DW_TAG_array_type");
      }
    }
  }

  DIERef type_die_ref(type_attr_value);
  Type *pointee_type = dwarf->ResolveTypeUID(type_die_ref);
  if (!pointee_type)
    return nullptr;

  CompilerType pointee_compiler_type = pointee_type->GetForwardCompilerType();
  CompilerType reference_compiler_type =
      m_ast.CreateReferenceType(pointee_compiler_type);
  TypeSP type_sp(
      new Type(die.GetID(), dwarf, reference_compiler_type.GetTypeName(), -1,
               nullptr, type_die_ref.GetUID(dwarf), Type::eEncodingIsUID, &decl,
               reference_compiler_type, Type::eResolveStateFull));
  type_sp->SetEncodingType(pointee_type);
  return type_sp;
}

lldb::TypeSP DWARFASTParserJava::ParseClassTypeFromDIE(const DWARFDIE &die,
                                                       bool &is_new_type) {
  SymbolFileDWARF *dwarf = die.GetDWARF();
  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;

  Declaration decl;
  ConstString name;
  ConstString linkage_name;
  bool is_forward_declaration = false;
  uint32_t byte_size = 0;

  DWARFAttributes attributes;
  const size_t num_attributes = die.GetAttributes(attributes);
  for (uint32_t i = 0; i < num_attributes; ++i) {
    DWARFFormValue form_value;
    dw_attr_t attr = attributes.AttributeAtIndex(i);
    if (attributes.ExtractFormValueAtIndex(i, form_value)) {
      switch (attr) {
      case DW_AT_name:
        name.SetCString(form_value.AsCString());
        break;
      case DW_AT_declaration:
        is_forward_declaration = form_value.Boolean();
        break;
      case DW_AT_byte_size:
        byte_size = form_value.Unsigned();
        break;
      case DW_AT_linkage_name:
        linkage_name.SetCString(form_value.AsCString());
        break;
      default:
        assert(false && "Unsupported attribute for DW_TAG_class_type");
      }
    }
  }

  UniqueDWARFASTType unique_ast_entry;
  if (name) {
    std::string qualified_name;
    if (die.GetQualifiedName(qualified_name)) {
      name.SetCString(qualified_name.c_str());
      if (dwarf->GetUniqueDWARFASTTypeMap().Find(name, die, Declaration(), -1,
                                                 unique_ast_entry)) {
        if (unique_ast_entry.m_type_sp) {
          dwarf->GetDIEToType()[die.GetDIE()] =
              unique_ast_entry.m_type_sp.get();
          is_new_type = false;
          return unique_ast_entry.m_type_sp;
        }
      }
    }
  }

  if (is_forward_declaration) {
    DWARFDeclContext die_decl_ctx;
    die.GetDWARFDeclContext(die_decl_ctx);

    TypeSP type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
    if (type_sp) {
      // We found a real definition for this type elsewhere so lets use it
      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
      is_new_type = false;
      return type_sp;
    }
  }

  CompilerType compiler_type(
      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
  if (!compiler_type)
    compiler_type = m_ast.CreateObjectType(name, linkage_name, byte_size);

  is_new_type = true;
  TypeSP type_sp(new Type(die.GetID(), dwarf, name,
                          -1, // byte size isn't specified
                          nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
                          &decl, compiler_type, Type::eResolveStateForward));

  // Add our type to the unique type map
  unique_ast_entry.m_type_sp = type_sp;
  unique_ast_entry.m_die = die;
  unique_ast_entry.m_declaration = decl;
  unique_ast_entry.m_byte_size = -1;
  dwarf->GetUniqueDWARFASTTypeMap().Insert(name, unique_ast_entry);

  if (!is_forward_declaration) {
    // Leave this as a forward declaration until we need to know the details of
    // the type
    dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
        compiler_type.GetOpaqueQualType();
    dwarf->GetForwardDeclClangTypeToDie()[compiler_type.GetOpaqueQualType()] =
        die.GetDIERef();
  }
  return type_sp;
}

lldb::TypeSP DWARFASTParserJava::ParseTypeFromDWARF(
    const lldb_private::SymbolContext &sc, const DWARFDIE &die,
    lldb_private::Log *log, bool *type_is_new_ptr) {
  if (type_is_new_ptr)
    *type_is_new_ptr = false;

  if (!die)
    return nullptr;

  SymbolFileDWARF *dwarf = die.GetDWARF();

  Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
  if (type_ptr == DIE_IS_BEING_PARSED)
    return nullptr;
  if (type_ptr != nullptr)
    return type_ptr->shared_from_this();

  TypeSP type_sp;
  if (type_is_new_ptr)
    *type_is_new_ptr = true;

  switch (die.Tag()) {
  case DW_TAG_base_type: {
    type_sp = ParseBaseTypeFromDIE(die);
    break;
  }
  case DW_TAG_array_type: {
    type_sp = ParseArrayTypeFromDIE(die);
    break;
  }
  case DW_TAG_class_type: {
    bool is_new_type = false;
    type_sp = ParseClassTypeFromDIE(die, is_new_type);
    if (!is_new_type)
      return type_sp;
    break;
  }
  case DW_TAG_reference_type: {
    type_sp = ParseReferenceTypeFromDIE(die);
    break;
  }
  }

  if (!type_sp)
    return nullptr;

  DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
  dw_tag_t sc_parent_tag = sc_parent_die.Tag();

  SymbolContextScope *symbol_context_scope = nullptr;
  if (sc_parent_tag == DW_TAG_compile_unit ||
      sc_parent_tag == DW_TAG_partial_unit) {
    symbol_context_scope = sc.comp_unit;
  } else if (sc.function != nullptr && sc_parent_die) {
    symbol_context_scope =
        sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
    if (symbol_context_scope == nullptr)
      symbol_context_scope = sc.function;
  }

  if (symbol_context_scope != nullptr)
    type_sp->SetSymbolContextScope(symbol_context_scope);

  dwarf->GetTypeList()->Insert(type_sp);
  dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();

  return type_sp;
}

lldb_private::Function *DWARFASTParserJava::ParseFunctionFromDWARF(
    const lldb_private::SymbolContext &sc, const DWARFDIE &die) {
  assert(die.Tag() == DW_TAG_subprogram);

  const char *name = nullptr;
  const char *mangled = nullptr;
  int decl_file = 0;
  int decl_line = 0;
  int decl_column = 0;
  int call_file = 0;
  int call_line = 0;
  int call_column = 0;
  DWARFRangeList func_ranges;
  DWARFExpression frame_base(die.GetCU());

  if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
                               decl_column, call_file, call_line, call_column,
                               &frame_base)) {
    // Union of all ranges in the function DIE (if the function is
    // discontiguous)
    AddressRange func_range;
    lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase(0);
    lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd(0);
    if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
        lowest_func_addr <= highest_func_addr) {
      ModuleSP module_sp(die.GetModule());
      func_range.GetBaseAddress().ResolveAddressUsingFileSections(
          lowest_func_addr, module_sp->GetSectionList());
      if (func_range.GetBaseAddress().IsValid())
        func_range.SetByteSize(highest_func_addr - lowest_func_addr);
    }

    if (func_range.GetBaseAddress().IsValid()) {
      std::unique_ptr<Declaration> decl_ap;
      if (decl_file != 0 || decl_line != 0 || decl_column != 0)
        decl_ap.reset(new Declaration(
            sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
            decl_line, decl_column));

      if (die.GetDWARF()->FixupAddress(func_range.GetBaseAddress())) {
        FunctionSP func_sp(new Function(sc.comp_unit, die.GetID(), die.GetID(),
                                        Mangled(ConstString(name), false),
                                        nullptr, // No function types in java
                                        func_range));
        if (frame_base.IsValid())
          func_sp->GetFrameBaseExpression() = frame_base;
        sc.comp_unit->AddFunction(func_sp);

        return func_sp.get();
      }
    }
  }
  return nullptr;
}

bool DWARFASTParserJava::CompleteTypeFromDWARF(
    const DWARFDIE &die, lldb_private::Type *type,
    lldb_private::CompilerType &java_type) {
  switch (die.Tag()) {
  case DW_TAG_class_type: {
    if (die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 0) {
      if (die.HasChildren())
        ParseChildMembers(die, java_type);
      m_ast.CompleteObjectType(java_type);
      return java_type.IsValid();
    }
  } break;
  default:
    assert(false && "Not a forward java type declaration!");
    break;
  }
  return false;
}

void DWARFASTParserJava::ParseChildMembers(const DWARFDIE &parent_die,
                                           CompilerType &compiler_type) {
  DWARFUnit *dwarf_cu = parent_die.GetCU();
  for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
       die = die.GetSibling()) {
    switch (die.Tag()) {
    case DW_TAG_member: {
      const char *name = nullptr;
      DWARFFormValue encoding_uid;
      uint32_t member_byte_offset = UINT32_MAX;
      DWARFExpression member_location_expression(dwarf_cu);

      DWARFAttributes attributes;
      size_t num_attributes = die.GetAttributes(attributes);
      for (size_t i = 0; i < num_attributes; ++i) {
        DWARFFormValue form_value;
        if (attributes.ExtractFormValueAtIndex(i, form_value)) {
          switch (attributes.AttributeAtIndex(i)) {
          case DW_AT_name:
            name = form_value.AsCString();
            break;
          case DW_AT_type:
            encoding_uid = form_value;
            break;
          case DW_AT_data_member_location:
            if (form_value.BlockData())
              member_location_expression.CopyOpcodeData(
                  form_value.BlockData(), form_value.Unsigned(),
                  dwarf_cu->GetByteOrder(), dwarf_cu->GetAddressByteSize());
            else
              member_byte_offset = form_value.Unsigned();
            break;
          case DW_AT_artificial:
            static_cast<void>(form_value.Boolean());
            break;
          case DW_AT_accessibility:
            // TODO: Handle when needed
            break;
          default:
            assert(false && "Unhandled attribute for DW_TAG_member");
            break;
          }
        }
      }

      if (strcmp(name, ".dynamic_type") == 0)
        m_ast.SetDynamicTypeId(compiler_type, member_location_expression);
      else {
        if (Type *member_type = die.ResolveTypeUID(DIERef(encoding_uid)))
          m_ast.AddMemberToObject(compiler_type, ConstString(name),
                                  member_type->GetFullCompilerType(),
                                  member_byte_offset);
      }
      break;
    }
    case DW_TAG_inheritance: {
      DWARFFormValue encoding_uid;
      uint32_t member_byte_offset = UINT32_MAX;

      DWARFAttributes attributes;
      size_t num_attributes = die.GetAttributes(attributes);
      for (size_t i = 0; i < num_attributes; ++i) {
        DWARFFormValue form_value;
        if (attributes.ExtractFormValueAtIndex(i, form_value)) {
          switch (attributes.AttributeAtIndex(i)) {
          case DW_AT_type:
            encoding_uid = form_value;
            break;
          case DW_AT_data_member_location:
            member_byte_offset = form_value.Unsigned();
            break;
          case DW_AT_accessibility:
            // In java all base class is public so we can ignore this attribute
            break;
          default:
            assert(false && "Unhandled attribute for DW_TAG_member");
            break;
          }
        }
      }
      if (Type *base_type = die.ResolveTypeUID(DIERef(encoding_uid)))
        m_ast.AddBaseClassToObject(compiler_type,
                                   base_type->GetFullCompilerType(),
                                   member_byte_offset);
      break;
    }
    default:
      break;
    }
  }
}