//===- RelocVisitor.h - Visitor for object file relocations -----*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides a wrapper around all the different types of relocations
// in different file formats, such that a client can handle them in a unified
// manner by only implementing a minimal number of functions.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_OBJECT_RELOCVISITOR_H
#define LLVM_OBJECT_RELOCVISITOR_H

#include "llvm/ADT/Triple.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/MachO.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MachO.h"
#include <cstdint>
#include <system_error>

namespace llvm {
namespace object {

struct RelocToApply {
  // The computed value after applying the relevant relocations.
  int64_t Value = 0;

  // The width of the value; how many bytes to touch when applying the
  // relocation.
  char Width = 0;

  RelocToApply() = default;
  RelocToApply(int64_t Value, char Width) : Value(Value), Width(Width) {}
};

/// @brief Base class for object file relocation visitors.
class RelocVisitor {
public:
  explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {}

  // TODO: Should handle multiple applied relocations via either passing in the
  // previously computed value or just count paired relocations as a single
  // visit.
  RelocToApply visit(uint32_t RelocType, RelocationRef R, uint64_t Value = 0) {
    if (isa<ELFObjectFileBase>(ObjToVisit))
      return visitELF(RelocType, R, Value);
    if (isa<COFFObjectFile>(ObjToVisit))
      return visitCOFF(RelocType, R, Value);
    if (isa<MachOObjectFile>(ObjToVisit))
      return visitMachO(RelocType, R, Value);

    HasError = true;
    return RelocToApply();
  }

  bool error() { return HasError; }

private:
  const ObjectFile &ObjToVisit;
  bool HasError = false;

  RelocToApply visitELF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
    if (ObjToVisit.getBytesInAddress() == 8) { // 64-bit object file
      switch (ObjToVisit.getArch()) {
      case Triple::x86_64:
        switch (RelocType) {
        case ELF::R_X86_64_NONE:
          return visitELF_X86_64_NONE(R);
        case ELF::R_X86_64_64:
          return visitELF_X86_64_64(R, Value);
        case ELF::R_X86_64_PC32:
          return visitELF_X86_64_PC32(R, Value);
        case ELF::R_X86_64_32:
          return visitELF_X86_64_32(R, Value);
        case ELF::R_X86_64_32S:
          return visitELF_X86_64_32S(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::aarch64:
      case Triple::aarch64_be:
        switch (RelocType) {
        case ELF::R_AARCH64_ABS32:
          return visitELF_AARCH64_ABS32(R, Value);
        case ELF::R_AARCH64_ABS64:
          return visitELF_AARCH64_ABS64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::bpfel:
      case Triple::bpfeb:
        switch (RelocType) {
        case ELF::R_BPF_64_64:
          return visitELF_BPF_64_64(R, Value);
        case ELF::R_BPF_64_32:
          return visitELF_BPF_64_32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::mips64el:
      case Triple::mips64:
        switch (RelocType) {
        case ELF::R_MIPS_32:
          return visitELF_MIPS64_32(R, Value);
        case ELF::R_MIPS_64:
          return visitELF_MIPS64_64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::ppc64le:
      case Triple::ppc64:
        switch (RelocType) {
        case ELF::R_PPC64_ADDR32:
          return visitELF_PPC64_ADDR32(R, Value);
        case ELF::R_PPC64_ADDR64:
          return visitELF_PPC64_ADDR64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::systemz:
        switch (RelocType) {
        case ELF::R_390_32:
          return visitELF_390_32(R, Value);
        case ELF::R_390_64:
          return visitELF_390_64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::sparcv9:
        switch (RelocType) {
        case ELF::R_SPARC_32:
        case ELF::R_SPARC_UA32:
          return visitELF_SPARCV9_32(R, Value);
        case ELF::R_SPARC_64:
        case ELF::R_SPARC_UA64:
          return visitELF_SPARCV9_64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::amdgcn:
        switch (RelocType) {
        case ELF::R_AMDGPU_ABS32:
          return visitELF_AMDGPU_ABS32(R, Value);
        case ELF::R_AMDGPU_ABS64:
          return visitELF_AMDGPU_ABS64(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      default:
        HasError = true;
        return RelocToApply();
      }
    } else if (ObjToVisit.getBytesInAddress() == 4) { // 32-bit object file
      switch (ObjToVisit.getArch()) {
      case Triple::x86:
        switch (RelocType) {
        case ELF::R_386_NONE:
          return visitELF_386_NONE(R);
        case ELF::R_386_32:
          return visitELF_386_32(R, Value);
        case ELF::R_386_PC32:
          return visitELF_386_PC32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::ppc:
        switch (RelocType) {
        case ELF::R_PPC_ADDR32:
          return visitELF_PPC_ADDR32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::arm:
      case Triple::armeb:
        switch (RelocType) {
        default:
          HasError = true;
          return RelocToApply();
        case ELF::R_ARM_ABS32:
          return visitELF_ARM_ABS32(R, Value);
        }
      case Triple::lanai:
        switch (RelocType) {
        case ELF::R_LANAI_32:
          return visitELF_Lanai_32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::mipsel:
      case Triple::mips:
        switch (RelocType) {
        case ELF::R_MIPS_32:
          return visitELF_MIPS_32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::sparc:
        switch (RelocType) {
        case ELF::R_SPARC_32:
        case ELF::R_SPARC_UA32:
          return visitELF_SPARC_32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      case Triple::hexagon:
        switch (RelocType) {
        case ELF::R_HEX_32:
          return visitELF_HEX_32(R, Value);
        default:
          HasError = true;
          return RelocToApply();
        }
      default:
        HasError = true;
        return RelocToApply();
      }
    } else {
      report_fatal_error("Invalid word size in object file");
    }
  }

  RelocToApply visitCOFF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
    switch (ObjToVisit.getArch()) {
    case Triple::x86:
      switch (RelocType) {
      case COFF::IMAGE_REL_I386_SECREL:
        return visitCOFF_I386_SECREL(R, Value);
      case COFF::IMAGE_REL_I386_DIR32:
        return visitCOFF_I386_DIR32(R, Value);
      }
      break;
    case Triple::x86_64:
      switch (RelocType) {
      case COFF::IMAGE_REL_AMD64_SECREL:
        return visitCOFF_AMD64_SECREL(R, Value);
      case COFF::IMAGE_REL_AMD64_ADDR64:
        return visitCOFF_AMD64_ADDR64(R, Value);
      }
      break;
    }
    HasError = true;
    return RelocToApply();
  }

  RelocToApply visitMachO(uint32_t RelocType, RelocationRef R, uint64_t Value) {
    switch (ObjToVisit.getArch()) {
    default: break;
    case Triple::x86_64:
      switch (RelocType) {
        default: break;
        case MachO::X86_64_RELOC_UNSIGNED:
          return visitMACHO_X86_64_UNSIGNED(R, Value);
      }
    }
    HasError = true;
    return RelocToApply();
  }

  int64_t getELFAddend(RelocationRef R) {
    ErrorOr<int64_t> AddendOrErr = ELFRelocationRef(R).getAddend();
    if (std::error_code EC = AddendOrErr.getError())
      report_fatal_error(EC.message());
    return *AddendOrErr;
  }

  uint8_t getLengthMachO64(RelocationRef R) {
    const MachOObjectFile *Obj = cast<MachOObjectFile>(R.getObject());
    return Obj->getRelocationLength(R.getRawDataRefImpl());
  }

  /// Operations

  /// 386-ELF
  RelocToApply visitELF_386_NONE(RelocationRef R) {
    return RelocToApply(0, 0);
  }

  // Ideally the Addend here will be the addend in the data for
  // the relocation. It's not actually the case for Rel relocations.
  RelocToApply visitELF_386_32(RelocationRef R, uint64_t Value) {
    return RelocToApply(Value, 4);
  }

  RelocToApply visitELF_386_PC32(RelocationRef R, uint64_t Value) {
    uint64_t Address = R.getOffset();
    return RelocToApply(Value - Address, 4);
  }

  /// X86-64 ELF
  RelocToApply visitELF_X86_64_NONE(RelocationRef R) {
    return RelocToApply(0, 0);
  }
  RelocToApply visitELF_X86_64_64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }
  RelocToApply visitELF_X86_64_PC32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint64_t Address = R.getOffset();
    return RelocToApply(Value + Addend - Address, 4);
  }
  RelocToApply visitELF_X86_64_32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }
  RelocToApply visitELF_X86_64_32S(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    int32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }

  /// BPF ELF
  RelocToApply visitELF_BPF_64_32(RelocationRef R, uint64_t Value) {
    uint32_t Res = Value & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }
  RelocToApply visitELF_BPF_64_64(RelocationRef R, uint64_t Value) {
    return RelocToApply(Value, 8);
  }

  /// PPC64 ELF
  RelocToApply visitELF_PPC64_ADDR32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }
  RelocToApply visitELF_PPC64_ADDR64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }

  /// PPC32 ELF
  RelocToApply visitELF_PPC_ADDR32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }

  /// Lanai ELF
  RelocToApply visitELF_Lanai_32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }

  /// MIPS ELF
  RelocToApply visitELF_MIPS_32(RelocationRef R, uint64_t Value) {
    uint32_t Res = Value & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }

  /// MIPS64 ELF
  RelocToApply visitELF_MIPS64_32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint32_t Res = (Value + Addend) & 0xFFFFFFFF;
    return RelocToApply(Res, 4);
  }

  RelocToApply visitELF_MIPS64_64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    uint64_t Res = (Value + Addend);
    return RelocToApply(Res, 8);
  }

  // AArch64 ELF
  RelocToApply visitELF_AARCH64_ABS32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    int64_t Res =  Value + Addend;

    // Overflow check allows for both signed and unsigned interpretation.
    if (Res < INT32_MIN || Res > UINT32_MAX)
      HasError = true;

    return RelocToApply(static_cast<uint32_t>(Res), 4);
  }

  RelocToApply visitELF_AARCH64_ABS64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }

  // SystemZ ELF
  RelocToApply visitELF_390_32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    int64_t Res = Value + Addend;

    // Overflow check allows for both signed and unsigned interpretation.
    if (Res < INT32_MIN || Res > UINT32_MAX)
      HasError = true;

    return RelocToApply(static_cast<uint32_t>(Res), 4);
  }

  RelocToApply visitELF_390_64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }

  RelocToApply visitELF_SPARC_32(RelocationRef R, uint32_t Value) {
    int32_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 4);
  }

  RelocToApply visitELF_SPARCV9_32(RelocationRef R, uint64_t Value) {
    int32_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 4);
  }

  RelocToApply visitELF_SPARCV9_64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }

  RelocToApply visitELF_ARM_ABS32(RelocationRef R, uint64_t Value) {
    int64_t Res = Value;

    // Overflow check allows for both signed and unsigned interpretation.
    if (Res < INT32_MIN || Res > UINT32_MAX)
      HasError = true;

    return RelocToApply(static_cast<uint32_t>(Res), 4);
  }

  RelocToApply visitELF_HEX_32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 4);
  }

  RelocToApply visitELF_AMDGPU_ABS32(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 4);
  }

  RelocToApply visitELF_AMDGPU_ABS64(RelocationRef R, uint64_t Value) {
    int64_t Addend = getELFAddend(R);
    return RelocToApply(Value + Addend, 8);
  }

  /// I386 COFF
  RelocToApply visitCOFF_I386_SECREL(RelocationRef R, uint64_t Value) {
    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
  }

  RelocToApply visitCOFF_I386_DIR32(RelocationRef R, uint64_t Value) {
    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
  }

  /// AMD64 COFF
  RelocToApply visitCOFF_AMD64_SECREL(RelocationRef R, uint64_t Value) {
    return RelocToApply(static_cast<uint32_t>(Value), /*Width=*/4);
  }

  RelocToApply visitCOFF_AMD64_ADDR64(RelocationRef R, uint64_t Value) {
    return RelocToApply(Value, /*Width=*/8);
  }

  // X86_64 MachO
  RelocToApply visitMACHO_X86_64_UNSIGNED(RelocationRef R, uint64_t Value) {
    uint8_t Length = getLengthMachO64(R);
    Length = 1<<Length;
    return RelocToApply(Value, Length);
  }
};

} // end namespace object
} // end namespace llvm

#endif // LLVM_OBJECT_RELOCVISITOR_H