// Copyright 2020 The Fuchsia Authors
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT

#include "phys/symbolize.h"

#include <inttypes.h>
#include <lib/boot-options/boot-options.h>
#include <lib/elfldltl/diagnostics.h>
#include <stdarg.h>
#include <stdint.h>
#include <zircon/assert.h>

#include <ktl/algorithm.h>
#include <ktl/iterator.h>
#include <ktl/string_view.h>
#include <phys/elf-image.h>
#include <phys/main.h>
#include <phys/stack.h>
#include <pretty/hexdump.h>

// The zx_*_t types used in the exception stuff aren't defined for 32-bit.
// There is no exception handling implementation for 32-bit.
#ifndef __i386__
#include <phys/exception.h>
#endif

#include <ktl/enforce.h>

Symbolize* gSymbolize = nullptr;

void Symbolize::ReplaceModulesStorage(ModuleList modules) {
  ModuleList old = ktl::exchange(modules_, ktl::move(modules));
  modules_.clear();
  for (const ElfImage* module : old) {
    AddModule(module);
  }
}

void Symbolize::AddModule(const ElfImage* module) {
  auto diag = elfldltl::PanicDiagnostics(name_, ": ");
  [[maybe_unused]] bool ok = modules_.push_back(diag, "too many modules loaded", module);
  ZX_DEBUG_ASSERT(ok);
}

const char* ProgramName() {
  if (gSymbolize) {
    return gSymbolize->name();
  }
  return "early-init";
}

elfldltl::ElfNote Symbolize::build_id() const {
  ZX_DEBUG_ASSERT(main_module_);
  ZX_DEBUG_ASSERT(main_module_->build_id());
  return main_module_->build_id().value();
}

void Symbolize::Printf(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);
  vfprintf(output_, fmt, args);
  va_end(args);
}

void Symbolize::ContextAlways(FILE* log) {
  decltype(writer_) log_writer{{log}};
  auto& writer = log ? log_writer : writer_;
  writer.Prefix(name_).Reset().Newline();
  for (size_t i = 0; i < modules_.size(); ++i) {
    modules_[i]->SymbolizerContext(writer, static_cast<unsigned int>(i), name_);
  }
}

void Symbolize::Context() {
  if (!context_done_) {
    context_done_ = true;
    ContextAlways();
  }
}

void Symbolize::OnLoad(const ElfImage& loaded) {
  if (context_done_) {
    loaded.SymbolizerContext(writer_, static_cast<unsigned int>(modules_.size()), name_);
  }
  AddModule(&loaded);
}

void Symbolize::OnHandoff(ElfImage& next) {
  // The module will usually be the among the latest added, so search in
  // reverse.
  auto it = ktl::find(modules().rbegin(), modules().rend(), &next);
  ZX_ASSERT_MSG(it != modules().rend(), "Module %.*s has not been loaded",
                static_cast<int>(next.name().size()), next.name().data());
  next.OnHandoff();
  main_module_ = &next;
}

void Symbolize::LogHandoff(ktl::string_view name, uintptr_t entry_pc) {
  writer_.Prefix(name_).Literal({"Hand off to ", name, " at "}).Code(entry_pc).Newline();
}

void Symbolize::BackTraceFrame(unsigned int n, uintptr_t pc, bool interrupt) {
  // Just print the line in markup format.  Context() was called earlier.
  writer_.Prefix(name_);
  interrupt ? writer_.ExactPcFrame(n, pc) : writer_.ReturnAddressFrame(n, pc);
  writer_.Newline();
}

void Symbolize::DumpFile(ktl::string_view announce, size_t size_bytes, ktl::string_view sink_name,
                         ktl::string_view vmo_name, ktl::string_view vmo_name_suffix) {
  Context();
  writer_.Prefix(name_).Prefix(announce).Dumpfile(sink_name, vmo_name, vmo_name_suffix);
  Printf(" %zu bytes\n", size_bytes);
}

void Symbolize::PrintBacktraces(const Symbolize::FramePointerBacktrace& frame_pointers,
                                const arch::ShadowCallStackBacktrace& shadow_call_stack,
                                ktl::optional<uintptr_t> interrupt_pc) {
  Context();

  // For either kind of backtrace, the interrupt_pc is a special frame #0 if
  // it's present.  It gets printed after other messages about the backtrace as
  // a whole, just as if it were stack.front() in a case with no interrupt_pc.
  auto backtrace = [configured_max = gBootOptions ? gBootOptions->phys_backtrace_max : 0,  //
                    this, interrupt_pc](const auto& stack, const char* which) PHYS_SINGLETHREAD {
    Printf("%s: Backtrace (via %s)%s%s\n", name_, which, stack.empty() ? " is empty!" : ":",
           (stack.empty() && interrupt_pc) ? "  Only the interrupted PC is available:" : "");
    if (interrupt_pc) {
      BackTraceFrame(0, *interrupt_pc, true);
      BackTrace(stack, 1, configured_max);
    } else {
      BackTrace(stack, 0, configured_max);
    }
  };

  backtrace(frame_pointers, "frame pointers");

  if (BootShadowCallStack::kEnabled) {
    backtrace(shadow_call_stack, "shadow call stack");
  }
}

void Symbolize::PrintStack(uintptr_t sp, ktl::optional<size_t> max_size_bytes) {
  const size_t configured_max = gBootOptions ? gBootOptions->phys_print_stack_max : 1024;
  auto maybe_dump_stack = [max = max_size_bytes.value_or(configured_max), sp,
                           this](const auto& stack) -> bool {
    if (!stack.boot_stack.IsOnStack(sp)) {
      return false;
    }
    Printf("%s: Partial dump of %V stack at [%p, %p):\n", name_, stack.name, &stack.boot_stack,
           &stack.boot_stack + 1);
    ktl::span whole(reinterpret_cast<const uint64_t*>(stack.boot_stack.stack),
                    sizeof(stack.boot_stack.stack) / sizeof(uint64_t));
    const uintptr_t base = reinterpret_cast<uintptr_t>(whole.data());
    ktl::span used = whole.subspan((sp - base) / sizeof(uint64_t));
    hexdump(used.data(), ktl::min(max, used.size_bytes()));
    return true;
  };

  if (ktl::none_of(stacks_.begin(), stacks_.end(), maybe_dump_stack)) {
    Printf("%s: Stack pointer is outside expected bounds:", name_);
    for (const auto& stack : stacks_) {
      Printf(" [%p, %p) ", &stack.boot_stack, &stack.boot_stack + 1);
    }
    Printf("\n");
  }
}

bool Symbolize::IsOnStack(uintptr_t sp) const {
  return ktl::any_of(stacks_.begin(), stacks_.end(),
                     [sp](auto&& stack) { return stack.boot_stack.IsOnStack(sp); });
}

arch::ShadowCallStackBacktrace Symbolize::GetShadowCallStackBacktrace(uintptr_t scsp) const {
  arch::ShadowCallStackBacktrace backtrace;
  for (const auto& stack : shadow_call_stacks_) {
    backtrace = stack.boot_stack.BackTrace(scsp);
    if (!backtrace.empty()) {
      break;
    }
  }
  return backtrace;
}

#ifndef __i386__

void Symbolize::PrintRegisters(const PhysExceptionState& exc) {
  Printf("%s: Registers stored at %p: {{{hexdict:", name_, &exc);

// TODO(https://fxbug.dev/42172753): Replace with a hexdict abstraction from
// libsymbolizer-markup.
#if defined(__aarch64__)

  for (size_t i = 0; i < ktl::size(exc.regs.r); ++i) {
    if (i % 4 == 0) {
      Printf("\n%s: ", name_);
    }
    Printf("  %sX%zu: 0x%016" PRIx64, i < 10 ? " " : "", i, exc.regs.r[i]);
  }
  Printf("  X30: 0x%016" PRIx64 "\n", exc.regs.lr);
  Printf("%s:    SP: 0x%016" PRIx64 "   PC: 0x%016" PRIx64 " SPSR: 0x%016" PRIx64 "\n", name_,
         exc.regs.sp, exc.regs.pc, exc.regs.cpsr);
  Printf("%s:   ESR: 0x%016" PRIx64 "  FAR: 0x%016" PRIx64 "\n", name_, exc.exc.arch.u.arm_64.esr,
         exc.exc.arch.u.arm_64.far);

#elif defined(__riscv)

  Printf("\n%s:   PC: 0x%016" PRIx64 "  RA: 0x%016" PRIx64 "  SP: 0x%016" PRIx64
         "  GP: 0x%016" PRIx64 "\n",
         name_, exc.regs.pc, exc.regs.ra, exc.regs.sp, exc.regs.gp);
  Printf("%s:   TP: 0x%016" PRIx64 "  T0: 0x%016" PRIx64 "  T1: 0x%016" PRIx64 "  T2: 0x%016" PRIx64
         "\n",
         name_, exc.regs.tp, exc.regs.t0, exc.regs.t1, exc.regs.t2);
  Printf("%s:   S0: 0x%016" PRIx64 "  S1: 0x%016" PRIx64 "  A0: 0x%016" PRIx64 "  A1: 0x%016" PRIx64
         "\n",
         name_, exc.regs.s0, exc.regs.s1, exc.regs.a0, exc.regs.a1);
  Printf("%s:   A2: 0x%016" PRIx64 "  A3: 0x%016" PRIx64 "  A4: 0x%016" PRIx64 "  A5: 0x%016" PRIx64
         "\n",
         name_, exc.regs.a2, exc.regs.a3, exc.regs.a4, exc.regs.a5);
  Printf("%s:   A6: 0x%016" PRIx64 "  A7: 0x%016" PRIx64 "  S2: 0x%016" PRIx64 "  S3: 0x%016" PRIx64
         "\n",
         name_, exc.regs.a6, exc.regs.a7, exc.regs.s2, exc.regs.s3);
  Printf("%s:   S4: 0x%016" PRIx64 "  S5: 0x%016" PRIx64 "  S6: 0x%016" PRIx64 "  S7: 0x%016" PRIx64
         "\n",
         name_, exc.regs.s4, exc.regs.s5, exc.regs.s6, exc.regs.s7);
  Printf("%s:   S8: 0x%016" PRIx64 "  S9: 0x%016" PRIx64 " S10: 0x%016" PRIx64 " S11: 0x%016" PRIx64
         "\n",
         name_, exc.regs.s8, exc.regs.s9, exc.regs.s10, exc.regs.s11);
  Printf("%s:   T3: 0x%016" PRIx64 "  T4: 0x%016" PRIx64 "  T5: 0x%016" PRIx64 "  T6: 0x%016" PRIx64
         "\n",
         name_, exc.regs.t3, exc.regs.t4, exc.regs.t6, exc.regs.t6);
  Printf("%s:   SCAUSE: 0x%016" PRIx64 "  STVAL: 0x%016" PRIx64 "\n", name_,
         exc.exc.arch.u.riscv_64.cause, exc.exc.arch.u.riscv_64.tval);

#elif defined(__x86_64__)

  const auto& exc_arch = exc.exc.arch.u.x86_64;
  Printf("\n%s:  RAX: 0x%016" PRIx64 " RBX: 0x%016" PRIx64 " RCX: 0x%016" PRIx64
         " RDX: 0x%016" PRIx64 "\n",
         name_, exc.regs.rax, exc.regs.rbx, exc.regs.rcx, exc.regs.rdx);
  Printf("%s:  RSI: 0x%016" PRIx64 " RDI: 0x%016" PRIx64 " RBP: 0x%016" PRIx64 " RSP: 0x%016" PRIx64
         "\n",
         name_, exc.regs.rsi, exc.regs.rdi, exc.regs.rbp, exc.regs.rsp);
  Printf("%s:   R8: 0x%016" PRIx64 "  R9: 0x%016" PRIx64 " R10: 0x%016" PRIx64 " R11: 0x%016" PRIx64
         "\n",
         name_, exc.regs.r8, exc.regs.r9, exc.regs.r10, exc.regs.r11);
  Printf("%s:  R12: 0x%016" PRIx64 " R13: 0x%016" PRIx64 " R14: 0x%016" PRIx64 " R15: 0x%016" PRIx64
         "\n",
         name_, exc.regs.r12, exc.regs.r13, exc.regs.r14, exc.regs.r15);
  Printf("%s:  RIP: 0x%016" PRIx64 " RFLAGS: 0x%08" PRIx64 " FS.BASE: 0x%016" PRIx64
         " GS.BASE: 0x%016" PRIx64 "\n",
         name_, exc.regs.rip, exc.regs.rflags, exc.regs.fs_base, exc.regs.gs_base);
  Printf("%s:   V#: %" PRIu64 "  ERR: %#" PRIx64 "  CR2: 0x%016" PRIx64 "\n", name_,
         exc_arch.vector, exc_arch.err_code, exc_arch.cr2);

#else

#warning "need register code dump for this architecture"

#endif

  Printf("%s: }}}\n", name_);
}

void Symbolize::PrintException(uint64_t vector, const char* vector_name,
                               const PhysExceptionState& exc) {
  // To avoid re-entry cascades from exceptions during the steps of this
  // function, maintain a progress indicator.
  enum Progress : unsigned int {
    kNotInUse,
    kEntered,
    kChecked,
    kVector,
    kContext,
    kRegs,
    kFp,
    kScs,
    kPrintBt,
    kStack,
    kStepLimit,
  };
  constexpr unsigned int kSteps = kStepLimit - 1;
  static Progress gProgress = kNotInUse;

  // `return_after(kJustDid)` returns false normally, and returns true if we
  // should bail out early because we've already gotten this far and re-entered
  // without getting farther.
  constexpr auto return_after = [](Progress step) -> bool {
    if (gProgress < step) [[likely]] {
      ZX_ASSERT_MSG(gProgress == step - 1, ": Hit return_after(%u) with gProgress=%u", step,
                    gProgress);
      gProgress = step;
      return false;
    }

    if (gProgress > step) {
      // This is a re-entry, but we haven't yet gotten as far as the last entry
      // got, so keep going to report details about the re-entry.
      printf(
          "PrintException reached step %u of %u on re-entry after previously reaching step %u.\n",
          step, kSteps, gProgress);
      return false;
    }

    // This is a re-entry after not getting farther than this last time.  So it
    // could be a cascade of repeated re-entry that would continue forever if
    // we attempted to go past the step just completed.  Don't even attempt a
    // printf here before recording the first step, so we identify a re-entry
    // that's just from printf on the early-return paths above for later steps.
    if (step != kEntered) {
      printf("PrintException truncated after %u of %u steps in re-entry.\n", step, kSteps);
    }
    return true;
  };

  // The kChecked step just makes sure we won't even try the printf in the
  // early-return case if we re-entered from that very printf at kChecked.
  if (return_after(kEntered) || return_after(kChecked)) {
    return;
  }

  Printf("%s: exception vector %s (%#" PRIx64 ")\n", Symbolize::name_, vector_name, vector);
  if (return_after(kVector)) {
    return;
  }

  // Always print the context, even if it was printed earlier.
  context_done_ = false;
  Context();
  if (return_after(kContext)) {
    return;
  }

  PrintRegisters(exc);
  if (return_after(kRegs)) {
    return;
  }

  // Collect each kind of backtrace if possible.
  FramePointerBacktrace fp_backtrace;
  arch::ShadowCallStackBacktrace scs_backtrace;

  fp_backtrace = FramePointerBacktrace::BackTrace(exc.fp());
  if (return_after(kFp)) {
    return;
  }

  uint64_t scsp = exc.shadow_call_sp();
  scs_backtrace = boot_shadow_call_stack.BackTrace(scsp);
  if (scs_backtrace.empty()) {
    scs_backtrace = phys_exception_shadow_call_stack.BackTrace(scsp);
  }
  if (return_after(kScs)) {
    return;
  }

  // Print whatever we have.
  PrintBacktraces(fp_backtrace, scs_backtrace, exc.pc());
  if (return_after(kPrintBt)) {
    return;
  }

  PrintStack(exc.sp());
  if (return_after(kStack)) {
    return;
  }

  gProgress = kNotInUse;
}

void PrintPhysException(uint64_t vector, const char* vector_name, const PhysExceptionState& regs) {
  if (gSymbolize) {
    gSymbolize->PrintException(vector, vector_name, regs);
  }
}

#endif  // !__i386__