// Copyright 2019 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "starboard/elf_loader/relocations.h"

#include "starboard/common/log.h"

namespace starboard {
namespace elf_loader {

Relocations::Relocations(Addr base_memory_address,
                         DynamicSection* dynamic_section,
                         ExportedSymbols* exported_symbols)
    : base_memory_address_(base_memory_address),
      dynamic_section_(dynamic_section),
      plt_relocations_(0),
      plt_relocations_size_(0),
      plt_got_(NULL),
      relocations_(0),
      relocations_size_(0),
      android_relocations_(NULL),
      android_relocations_size_(0),
      has_text_relocations_(false),
      has_symbolic_(false),
      exported_symbols_(exported_symbols) {}

bool Relocations::HasTextRelocations() {
  return has_text_relocations_;
}

bool Relocations::InitRelocations() {
  SB_LOG(INFO) << "InitRelocations: dynamic_count="
               << dynamic_section_->GetDynamicTableSize();
  const Dyn* dynamic = dynamic_section_->GetDynamicTable();
  for (int i = 0; i < dynamic_section_->GetDynamicTableSize(); i++) {
    Addr dyn_value = dynamic[i].d_un.d_val;
    uintptr_t dyn_addr = base_memory_address_ + dynamic[i].d_un.d_ptr;
    Addr tag = dynamic[i].d_tag;
    SB_LOG(INFO) << "InitRelocations: tag=" << tag;
    switch (tag) {
#if defined(USE_RELA)
      case DT_REL:
      case DT_RELSZ:
      case DT_ANDROID_REL:
      case DT_ANDROID_RELSZ:
#else
      case DT_RELA:
      case DT_RELASZ:
      case DT_ANDROID_RELA:
      case DT_ANDROID_RELASZ:
#endif
        SB_LOG(ERROR) << "unsupported relocation type";
        return false;
      case DT_PLTREL:
        SB_LOG(INFO) << "  DT_PLTREL value=" << dyn_value;
#if defined(USE_RELA)
        if (dyn_value != DT_RELA) {
          SB_LOG(ERROR) << "unsupported DT_PLTREL  expected DT_RELA";
          return false;
        }
#else
        if (dyn_value != DT_REL) {
          SB_LOG(ERROR) << "unsupported DT_PLTREL expected DT_REL";
          return false;
        }
#endif
        break;
      case DT_JMPREL:
        SB_LOG(INFO) << "  DT_JMPREL addr=0x" << std::hex
                     << (dyn_addr - base_memory_address_);
        plt_relocations_ = dyn_addr;
        break;
      case DT_PLTRELSZ:
        plt_relocations_size_ = dyn_value;
        SB_LOG(INFO) << "  DT_PLTRELSZ size=" << dyn_value;
        break;
#if defined(USE_RELA)
      case DT_RELA:
#else
      case DT_REL:
#endif
        SB_LOG(INFO) << "  " << ((tag == DT_RELA) ? "DT_RELA" : "DT_REL")
                     << " addr=" << std::hex
                     << (dyn_addr - base_memory_address_);
        if (relocations_) {
          SB_LOG(ERROR)
              << "Unsupported DT_RELA/DT_REL combination in dynamic section";
          return false;
        }
        relocations_ = dyn_addr;
        break;
#if defined(USE_RELA)
      case DT_RELASZ:
#else
      case DT_RELSZ:
#endif
        SB_LOG(INFO) << "  " << ((tag == DT_RELASZ) ? "DT_RELASZ" : "DT_RELSZ")
                     << " size=" << dyn_value;
        relocations_size_ = dyn_value;
        break;
#if defined(USE_RELA)
      case DT_ANDROID_RELA:
#else
      case DT_ANDROID_REL:
#endif
        SB_LOG(INFO) << "  "
                     << ((tag == DT_ANDROID_REL) ? "DT_ANDROID_REL"
                                                 : "DT_ANDROID_RELA")
                     << " addr=" << std::hex
                     << (dyn_addr - base_memory_address_);
        if (android_relocations_) {
          SB_LOG(ERROR) << "Multiple DT_ANDROID_* sections defined.";
          return false;
        }
        android_relocations_ = reinterpret_cast<uint8_t*>(dyn_addr);
        break;
#if defined(USE_RELA)
      case DT_ANDROID_RELASZ:
#else
      case DT_ANDROID_RELSZ:
#endif
        SB_LOG(ERROR) << "  DT_ANDROID_RELSZ NOT IMPELMENTED";
        android_relocations_size_ = dyn_value;
        break;
      case DT_RELR:
      case DT_ANDROID_RELR:
        SB_LOG(ERROR) << "  DT_RELR NOT IMPELMENTED";
        break;
      case DT_ANDROID_RELRSZ:
      case DT_RELRSZ:
        SB_LOG(ERROR) << "  DT_RELRSZ NOT IMPELMENTED";
        break;
      case DT_RELRENT:
      case DT_ANDROID_RELRENT:
        if (dyn_value != sizeof(Relr)) {
          SB_LOG(ERROR) << "Invalid DT_RELRENT value=" << std::hex
                        << static_cast<int>(dyn_value)
                        << " expected=" << static_cast<int>(sizeof(Relr));
          return false;
        }
        break;
      case DT_PLTGOT:
        SB_LOG(INFO) << "DT_PLTGOT addr=0x" << std::hex
                     << (dyn_addr - base_memory_address_);
        plt_got_ = reinterpret_cast<Addr*>(dyn_addr);
        break;
      case DT_TEXTREL:
        SB_LOG(INFO) << "  DT_TEXTREL";
        has_text_relocations_ = true;
        break;
      case DT_SYMBOLIC:
        SB_LOG(INFO) << "  DT_SYMBOLIC";
        has_symbolic_ = true;
        break;
      case DT_FLAGS:
        if (dyn_value & DF_TEXTREL)
          has_text_relocations_ = true;
        if (dyn_value & DF_SYMBOLIC)
          has_symbolic_ = true;

        SB_LOG(INFO) << "  DT_FLAGS has_text_relocations="
                     << has_text_relocations_
                     << " has_symbolic=" << has_symbolic_;

        break;
      default:
        break;
    }
  }

  return true;
}

bool Relocations::ApplyAllRelocations() {
  SB_LOG(INFO) << "Applying regular relocations";
  if (!ApplyRelocations(reinterpret_cast<rel_t*>(relocations_),
                        relocations_size_ / sizeof(rel_t))) {
    SB_LOG(ERROR) << "regular relocations failed";
    return false;
  }

  SB_LOG(INFO) << "Applying PLT relocations";
  if (!ApplyRelocations(reinterpret_cast<rel_t*>(plt_relocations_),
                        plt_relocations_size_ / sizeof(rel_t))) {
    SB_LOG(ERROR) << "PLT relocations failed";
    return false;
  }
  return true;
}

bool Relocations::ApplyRelocations(const rel_t* rel, size_t rel_count) {
  SB_LOG(INFO) << "rel=" << std::hex << rel << std::dec
               << " rel_count=" << rel_count;

  if (!rel)
    return true;

  for (size_t rel_n = 0; rel_n < rel_count; rel++, rel_n++) {
    SB_LOG(INFO) << "  Relocation " << rel_n + 1 << " of " << rel_count;

    if (!ApplyRelocation(rel))
      return false;
  }

  return true;
}

bool Relocations::ApplyRelocation(const rel_t* rel) {
  const Word rel_type = ELF_R_TYPE(rel->r_info);
  const Word rel_symbol = ELF_R_SYM(rel->r_info);

  Addr sym_addr = 0;
  Addr reloc = static_cast<Addr>(rel->r_offset + base_memory_address_);
  SB_LOG(INFO) << "  offset=0x" << std::hex << rel->r_offset
               << " type=" << std::dec << rel_type << " reloc=0x" << std::hex
               << reloc << " symbol=" << rel_symbol;

  if (rel_type == 0)
    return true;

  if (rel_symbol != 0) {
    if (!ResolveSymbol(rel_type, rel_symbol, reloc, &sym_addr)) {
      SB_LOG(ERROR) << "Failed to resolve symbol: " << rel_symbol;
      return false;
    }
  }

  return ApplyResolvedReloc(rel, sym_addr);
}

#if defined(USE_RELA)
bool Relocations::ApplyResolvedReloc(const Rela* rela, Addr sym_addr) {
  const Word rela_type = ELF_R_TYPE(rela->r_info);
  const Word rela_symbol = ELF_R_SYM(rela->r_info);
  const Sword addend = rela->r_addend;
  const Addr reloc = static_cast<Addr>(rela->r_offset + base_memory_address_);

  SB_LOG(INFO) << "  rela reloc=0x" << std::hex << reloc << " offset=0x"
               << rela->r_offset << " type=" << std::dec << rela_type
               << " addend=0x" << std::hex << addend;
  Addr* target = reinterpret_cast<Addr*>(reloc);
  switch (rela_type) {
#if SB_IS(ARCH_ARM) && SB_IS(64_BIT)
    case R_AARCH64_JUMP_SLOT:
      SB_LOG(INFO) << "  R_AARCH64_JUMP_SLOT target=" << std::hex << target
                   << " addr=" << (sym_addr + addend);
      *target = sym_addr + addend;
      break;

    case R_AARCH64_GLOB_DAT:
      SB_LOG(INFO) << " R_AARCH64_GLOB_DAT target=" << std::hex << target
                   << " addr=" << (sym_addr + addend);
      *target = sym_addr + addend;
      break;

    case R_AARCH64_ABS64:
      SB_LOG(INFO) << "  R_AARCH64_ABS64 target=" << std::hex << target << " "
                   << *target << " addr=" << sym_addr + addend;
      *target += sym_addr + addend;
      break;

    case R_AARCH64_RELATIVE:
      SB_LOG(INFO) << "  R_AARCH64_RELATIVE target=" << std::hex << target
                   << " " << *target
                   << " bias=" << base_memory_address_ + addend;
      if (!rela_symbol) {
        SB_LOG(ERROR) << "Invalid relative relocation with symbol";
        return false;
      }
      *target = base_memory_address_ + addend;
      break;

    case R_AARCH64_COPY:
      // NOTE: These relocations are forbidden in shared libraries.
      SB_LOG(ERROR) << "Invalid R_AARCH64_COPY relocation in shared library";
      return false;
#endif

#if SB_IS(ARCH_X86) && SB_IS(64_BIT)
    case R_X86_64_JMP_SLOT:
      SB_LOG(INFO) << "  R_X86_64_JMP_SLOT target=" << std::hex << target
                   << " addr=" << (sym_addr + addend);
      *target = sym_addr + addend;
      break;

    case R_X86_64_GLOB_DAT:
      SB_LOG(INFO) << "  R_X86_64_GLOB_DAT target=" << std::hex << target
                   << " addr=" << (sym_addr + addend);

      *target = sym_addr + addend;
      break;

    case R_X86_64_RELATIVE:
      if (rela_symbol) {
        SB_LOG(ERROR) << "Invalid R_X86_64_RELATIVE";
        return false;
      }

      SB_LOG(INFO) << "  R_X86_64_RELATIVE target=" << std::hex << target << " "
                   << *target << " bias=" << base_memory_address_ + addend;
      *target = base_memory_address_ + addend;
      break;

    case R_X86_64_64:
      *target = sym_addr + addend;
      break;

    case R_X86_64_PC32:
      *target = sym_addr + (addend - reloc);
      break;
#endif

    default:
      SB_LOG(ERROR) << "Invalid relocation type: " << rela_type;
      return false;
  }

  return true;
}
#else
bool Relocations::ApplyResolvedReloc(const Rel* rel, Addr sym_addr) {
  const Word rel_type = ELF_R_TYPE(rel->r_info);
  const Word rel_symbol = ELF_R_SYM(rel->r_info);

  const Addr reloc = static_cast<Addr>(rel->r_offset + base_memory_address_);

  SB_LOG(INFO) << "  rel reloc=0x" << std::hex << reloc << " offset=0x"
               << rel->r_offset << " type=" << std::dec << rel_type;

  Addr* target = reinterpret_cast<Addr*>(reloc);
  switch (rel_type) {
#if SB_IS(ARCH_ARM) && SB_IS(32_BIT)
    case R_ARM_JUMP_SLOT:
      SB_LOG(INFO) << "  R_ARM_JUMP_SLOT target=" << std::hex << target
                   << " addr=" << sym_addr;
      *target = sym_addr;
      break;

    case R_ARM_GLOB_DAT:
      SB_LOG(INFO) << "  R_ARM_GLOB_DAT target=" << std::hex << target
                   << " addr=" << sym_addr;
      *target = sym_addr;
      break;

    case R_ARM_ABS32:
      SB_LOG(INFO) << "  R_ARM_ABS32 target=" << std::hex << target << " "
                   << *target << " addr=" << sym_addr;
      *target += sym_addr;
      break;

    case R_ARM_REL32:
      SB_LOG(INFO) << "  R_ARM_REL32 target=" << std::hex << target << " "
                   << *target << " addr=" << sym_addr
                   << " offset=" << rel->r_offset;
      *target += sym_addr - rel->r_offset;
      break;

    case R_ARM_RELATIVE:
      SB_LOG(INFO) << "  RR_ARM_RELATIVE target=" << std::hex << target << " "
                   << *target << " bias=" << base_memory_address_;
      if (!rel_symbol) {
        SB_LOG(ERROR) << "Invalid relative relocation with symbol";
        return false;
      }
      *target += base_memory_address_;
      break;

    case R_ARM_COPY:
      // NOTE: These relocations are forbidden in shared libraries.
      // The Android linker has special code to deal with this, which
      // is not needed here.
      SB_LOG(ERROR) << "Invalid R_ARM_COPY relocation in shared library";

      return false;
#endif

#if SB_IS(ARCH_X86) && SB_IS(32_BIT)
    case R_386_JMP_SLOT:
      SB_LOG(INFO) << "  R_386_JMP_SLOT target=" << std::hex << target
                   << " addr=" << sym_addr;

      *target = sym_addr;
      break;

    case R_386_GLOB_DAT:
      SB_LOG(INFO) << "  R_386_GLOB_DAT target=" << std::hex << target
                   << " addr=" << sym_addr;
      *target = sym_addr;

      break;

    case R_386_RELATIVE:
      if (rel_symbol) {
        SB_LOG(ERROR) << "Invalid relative relocation with symbol";
        return false;
      }
      SB_LOG(INFO) << "  R_386_RELATIVE target=" << std::hex << target << " "
                   << *target << " bias=" << base_memory_address_;

      *target += base_memory_address_;
      break;

    case R_386_32:
      SB_LOG(INFO) << "  R_386_32 target=" << std::hex << target << " "
                   << *target << " addr=" << sym_addr;
      *target += sym_addr;
      break;

    case R_386_PC32:
      SB_LOG(INFO) << "  R_386_PC32 target=" << std::hex << target << " "
                   << *target << " addr=" << sym_addr << " reloc=" << reloc;
      *target += (sym_addr - reloc);
      break;
#endif

    default:
      SB_LOG(ERROR) << "Invalid relocation type: " << rel_type;
      return false;
  }

  return true;
}
#endif

RelocationType Relocations::GetRelocationType(Word r_type) {
  switch (r_type) {
#if SB_IS(ARCH_ARM) && SB_IS(32_BIT)
    case R_ARM_JUMP_SLOT:
    case R_ARM_GLOB_DAT:
    case R_ARM_ABS32:
      return RELOCATION_TYPE_ABSOLUTE;

    case R_ARM_REL32:
    case R_ARM_RELATIVE:
      return RELOCATION_TYPE_RELATIVE;

    case R_ARM_COPY:
      return RELOCATION_TYPE_COPY;
#endif

#if SB_IS(ARCH_ARM) && SB_IS(64_BIT)
    case R_AARCH64_JUMP_SLOT:
    case R_AARCH64_GLOB_DAT:
    case R_AARCH64_ABS64:
      return RELOCATION_TYPE_ABSOLUTE;

    case R_AARCH64_RELATIVE:
      return RELOCATION_TYPE_RELATIVE;

    case R_AARCH64_COPY:
      return RELOCATION_TYPE_COPY;
#endif

#if SB_IS(ARCH_X86) && SB_IS(32_BIT)
    case R_386_JMP_SLOT:
    case R_386_GLOB_DAT:
    case R_386_32:
      return RELOCATION_TYPE_ABSOLUTE;

    case R_386_RELATIVE:
      return RELOCATION_TYPE_RELATIVE;

    case R_386_PC32:
      return RELOCATION_TYPE_PC_RELATIVE;
#endif

#if SB_IS(ARCH_X86) && SB_IS(64_BIT)
    case R_X86_64_JMP_SLOT:
    case R_X86_64_GLOB_DAT:
    case R_X86_64_64:
      return RELOCATION_TYPE_ABSOLUTE;

    case R_X86_64_RELATIVE:
      return RELOCATION_TYPE_RELATIVE;

    case R_X86_64_PC32:
      return RELOCATION_TYPE_PC_RELATIVE;
#endif
    default:
      return RELOCATION_TYPE_UNKNOWN;
  }
}

bool Relocations::ResolveSymbol(Word rel_type,
                                Word rel_symbol,
                                Addr reloc,
                                Addr* sym_addr) {
  const char* sym_name = dynamic_section_->LookupNameById(rel_symbol);
  SB_LOG(INFO) << "Resolve: " << sym_name;
  const void* address = NULL;

  const Sym* sym = dynamic_section_->LookupByName(sym_name);
  if (sym) {
    address = reinterpret_cast<void*>(base_memory_address_ + sym->st_value);
  } else {
    address = exported_symbols_->Lookup(sym_name);
  }

  SB_LOG(INFO) << "Resolve: address=0x" << std::hex << address;

  if (address) {
    // The symbol was found, so compute its address.
    *sym_addr = reinterpret_cast<Addr>(address);
    return true;
  }

  // The symbol was not found. Normally this is an error except
  // if this is a weak reference.
  if (!dynamic_section_->IsWeakById(rel_symbol)) {
    SB_LOG(ERROR) << "Could not find symbol: " << sym_name;
    return false;
  }

  // IHI0044C AAELF 4.5.1.1:
  // Libraries are not searched to resolve weak references.
  // It is not an error for a weak reference to remain
  // unsatisfied.
  //
  // During linking, the value of an undefined weak reference is:
  // - Zero if the relocation type is absolute
  // - The address of the place if the relocation is pc-relative
  // - The address of nominal base address if the relocation
  //   type is base-relative.
  RelocationType r = GetRelocationType(rel_type);
  if (r == RELOCATION_TYPE_ABSOLUTE || r == RELOCATION_TYPE_RELATIVE) {
    *sym_addr = 0;
    return true;
  }

  if (r == RELOCATION_TYPE_PC_RELATIVE) {
    *sym_addr = reloc;
    return true;
  }

  SB_LOG(ERROR) << "Invalid weak relocation type (" << r
                << ") for unknown symbol '" << sym_name << "'";
  return false;
}
}  // namespace elf_loader
}  // namespace starboard