// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "tools/fidlcat/lib/syscall_decoder.h"

#include <lib/syslog/cpp/macros.h>
#include <sys/time.h>
#include <zircon/types.h>

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>

#include "src/developer/debug/zxdb/client/breakpoint.h"
#include "src/developer/debug/zxdb/client/frame.h"
#include "src/developer/debug/zxdb/client/memory_dump.h"
#include "src/developer/debug/zxdb/client/process.h"
#include "src/developer/debug/zxdb/client/step_thread_controller.h"
#include "src/developer/debug/zxdb/client/thread.h"
#include "src/developer/debug/zxdb/symbols/symbol.h"
#include "tools/fidlcat/lib/interception_workflow.h"
#include "tools/fidlcat/lib/type_decoder.h"

namespace fidlcat {

constexpr int kBitsPerByte = 8;

// Helper function to convert a vector of bytes to a T.
template <typename T>
T GetValueFromBytes(const std::vector<uint8_t>& bytes, size_t offset) {
  T ret = 0;
  for (size_t i = 0; (i < sizeof(ret)) && (offset < bytes.size()); i++) {
    ret |= static_cast<uint64_t>(bytes[offset++]) << (i * kBitsPerByte);
  }
  return ret;
}

uint64_t GetRegisterValue(const std::vector<debug_ipc::Register>& general_registers,
                          const debug_ipc::RegisterID register_id) {
  for (const auto& reg : general_registers) {
    if (reg.id == register_id) {
      return GetValueFromBytes<uint64_t>(reg.data, 0);
    }
  }
  return 0;
}

void MemoryDumpToVector(const zxdb::MemoryDump& dump, std::vector<uint8_t>* output_vector) {
  output_vector->reserve(dump.size());
  for (const debug_ipc::MemoryBlock& block : dump.blocks()) {
    FX_DCHECK(block.valid);
    for (size_t offset = 0; offset < block.size; ++offset) {
      output_vector->push_back(block.data[offset]);
    }
  }
}

void SyscallUse::SyscallInputsDecoded(SyscallDecoder* decoder) {}

void SyscallUse::SyscallOutputsDecoded(SyscallDecoder* decoder) {}

void SyscallUse::SyscallDecodingError(const DecoderError& error, SyscallDecoder* decoder) {
  FX_LOGS(ERROR) << error.message();
  decoder->Destroy();
}

SyscallDecoder::SyscallDecoder(SyscallDecoderDispatcher* dispatcher,
                               InterceptingThreadObserver* thread_observer, zxdb::Thread* thread,
                               const Syscall* syscall, std::unique_ptr<SyscallUse> use,
                               int64_t timestamp)
    : dispatcher_(dispatcher),
      thread_observer_(thread_observer),
      weak_thread_(thread->GetWeakPtr()),
      arch_(thread->session()->arch()),
      syscall_(syscall),
      use_(std::move(use)),
      timestamp_(timestamp) {
  fidlcat_thread_ = dispatcher_->SearchThread(thread->GetKoid());
  if (fidlcat_thread_ == nullptr) {
    Process* fidlcat_process = dispatcher_->SearchProcess(thread->GetProcess()->GetKoid());
    if (fidlcat_process == nullptr) {
      fidlcat_process = dispatcher_->CreateProcess(thread->GetProcess()->GetName(),
                                                   thread->GetProcess()->GetKoid(),
                                                   thread->GetProcess()->GetWeakPtr());
    }
    fidlcat_thread_ = dispatcher_->CreateThread(thread->GetKoid(), fidlcat_process);
  }
}

void SyscallDecoder::LoadMemory(uint64_t address, size_t size, std::vector<uint8_t>* destination) {
  if (address == 0) {
    // Null pointer => don't load anything.
    return;
  }
  zxdb::Thread* thread = get_thread();
  if (thread == nullptr) {
    aborted_ = true;
    Destroy();
  }
  ++pending_request_count_;
  thread->GetProcess()->ReadMemory(
      address, size,
      [this, address, size, destination](const zxdb::Err& err, zxdb::MemoryDump dump) {
        --pending_request_count_;
        if (aborted()) {
          Destroy();
        } else {
          if (!err.ok()) {
            Error(DecoderError::Type::kCantReadMemory)
                << "Can't load memory at " << address << ": " << err.msg();
          } else if ((dump.size() != size) || !dump.AllValid()) {
            Error(DecoderError::Type::kCantReadMemory)
                << "Can't load memory at " << address << ": not enough data";
          } else {
            MemoryDumpToVector(dump, destination);
          }
          if (input_arguments_loaded_) {
            LoadOutputs();
          } else {
            LoadInputs();
          }
        }
      });
}

void SyscallDecoder::LoadArgument(Stage stage, int argument_index, size_t size) {
  if (decoded_arguments_[argument_index].loading(stage)) {
    return;
  }
  decoded_arguments_[argument_index].set_loading(stage);
  LoadMemory(ArgumentValue(argument_index), size,
             &decoded_arguments_[argument_index].loaded_values(stage));
}

void SyscallDecoder::LoadBuffer(Stage stage, uint64_t address, size_t size) {
  if (address == 0) {
    return;
  }
  SyscallDecoderBuffer& buffer = buffers_[std::make_pair(stage, address)];
  if (buffer.loading()) {
    return;
  }
  buffer.set_loading();
  LoadMemory(address, size, &buffer.loaded_values());
}

void SyscallDecoder::Decode() {
  zxdb::Thread* thread = weak_thread_.get();
  if (aborted_ || (thread == nullptr) || (thread->GetStack().size() == 0)) {
    aborted_ = true;
    Destroy();
    return;
  }
  if (dispatcher_->decode_options().stack_level >= kFullStack) {
    thread->GetStack().SyncFrames([this](const zxdb::Err& /*err*/) { DoDecode(); });
  } else {
    DoDecode();
  }
}

void SyscallDecoder::DoDecode() {
  zxdb::Thread* thread = weak_thread_.get();
  if (aborted_ || (thread == nullptr) || (thread->GetStack().size() == 0)) {
    aborted_ = true;
    Destroy();
    return;
  }
  const zxdb::Stack& stack = thread->GetStack();
  // Don't keep the inner frame which is the syscall and is not useful.
  for (size_t i = stack.size() - 1; i > 0; --i) {
    const zxdb::Frame* caller = stack[i];
    caller_locations_.push_back(caller->GetLocation());
  }
  const std::vector<debug_ipc::Register>* general_registers =
      thread->GetStack()[0]->GetRegisterCategorySync(debug_ipc::RegisterCategory::kGeneral);
  FX_DCHECK(general_registers);  // General registers should always be available synchronously.

  // The order of parameters in the System V AMD64 ABI we use, according to
  // Wikipedia:
  static std::vector<debug_ipc::RegisterID> amd64_abi = {
      debug_ipc::RegisterID::kX64_rdi, debug_ipc::RegisterID::kX64_rsi,
      debug_ipc::RegisterID::kX64_rdx, debug_ipc::RegisterID::kX64_rcx,
      debug_ipc::RegisterID::kX64_r8,  debug_ipc::RegisterID::kX64_r9};

  // The order of parameters in the System V AArch64 ABI we use, according to
  // Wikipedia:
  static std::vector<debug_ipc::RegisterID> aarch64_abi = {
      debug_ipc::RegisterID::kARMv8_x0, debug_ipc::RegisterID::kARMv8_x1,
      debug_ipc::RegisterID::kARMv8_x2, debug_ipc::RegisterID::kARMv8_x3,
      debug_ipc::RegisterID::kARMv8_x4, debug_ipc::RegisterID::kARMv8_x5,
      debug_ipc::RegisterID::kARMv8_x6, debug_ipc::RegisterID::kARMv8_x7};

  const std::vector<debug_ipc::RegisterID>* abi;
  if (arch_ == debug_ipc::Arch::kX64) {
    abi = &amd64_abi;
    entry_sp_ = GetRegisterValue(*general_registers, debug_ipc::RegisterID::kX64_rsp);
  } else if (arch_ == debug_ipc::Arch::kArm64) {
    abi = &aarch64_abi;
    entry_sp_ = GetRegisterValue(*general_registers, debug_ipc::RegisterID::kARMv8_sp);
    return_address_ = GetRegisterValue(*general_registers, debug_ipc::RegisterID::kARMv8_lr);
  } else {
    Error(DecoderError::Type::kUnknownArchitecture) << "Unknown architecture";
    if (pending_request_count_ == 0) {
      use_->SyscallDecodingError(error_, this);
    }
    return;
  }

  size_t argument_count = syscall_->arguments().size();
  decoded_arguments_.reserve(argument_count);
  size_t register_count = std::min(argument_count, abi->size());
  for (size_t i = 0; i < register_count; i++) {
    decoded_arguments_.emplace_back(GetRegisterValue(*general_registers, (*abi)[i]));
  }

  LoadStack();
}

void SyscallDecoder::LoadStack() {
  zxdb::Thread* thread = weak_thread_.get();
  if (aborted_ || (thread == nullptr) || (thread->GetStack().size() == 0)) {
    aborted_ = true;
    Destroy();
    return;
  }
  size_t stack_size = (syscall_->arguments().size() - decoded_arguments_.size()) * sizeof(uint64_t);
  if (arch_ == debug_ipc::Arch::kX64) {
    stack_size += sizeof(uint64_t);
  }
  if (stack_size == 0) {
    LoadInputs();
    return;
  }
  uint64_t address = entry_sp_;
  ++pending_request_count_;
  thread->GetProcess()->ReadMemory(
      address, stack_size,
      [this, address, stack_size](const zxdb::Err& err, zxdb::MemoryDump dump) {
        --pending_request_count_;
        if (aborted()) {
          Destroy();
        } else {
          if (!err.ok()) {
            Error(DecoderError::Type::kCantReadMemory)
                << "Can't load stack at " << address << '/' << stack_size << ": " << err.msg();
          } else if ((dump.size() != stack_size) || !dump.AllValid()) {
            Error(DecoderError::Type::kCantReadMemory)
                << "Can't load stack at " << address << '/' << stack_size << ": not enough data";
          } else {
            std::vector<uint8_t> data;
            MemoryDumpToVector(dump, &data);
            size_t offset = 0;
            if (arch_ == debug_ipc::Arch::kX64) {
              return_address_ = GetValueFromBytes<uint64_t>(data, 0);
              offset += sizeof(uint64_t);
            }
            while (offset < data.size()) {
              decoded_arguments_.emplace_back(GetValueFromBytes<uint64_t>(data, offset));
              offset += sizeof(uint64_t);
            }
          }
          LoadInputs();
        }
      });
}

void SyscallDecoder::LoadInputs() {
  if (error_.type() != DecoderError::Type::kNone) {
    if (pending_request_count_ == 0) {
      use_->SyscallDecodingError(error_, this);
    }
    return;
  }
  for (const auto& input : syscall_->inputs()) {
    if (input->ConditionsAreTrue(this, Stage::kEntry)) {
      input->Load(this, Stage::kEntry);
    }
  }
  if (pending_request_count_ > 0) {
    return;
  }
  input_arguments_loaded_ = true;
  if (error_.type() != DecoderError::Type::kNone) {
    use_->SyscallDecodingError(error_, this);
  } else {
    if (StepToReturnAddress()) {
      DecodeInputs();
    }
  }
}

bool SyscallDecoder::StepToReturnAddress() {
  zxdb::Thread* thread = weak_thread_.get();
  if (aborted_ || (thread == nullptr) || (thread->GetStack().size() == 0)) {
    aborted_ = true;
    Destroy();
    return false;
  }

  if (syscall_->return_type() != SyscallReturnType::kNoReturn) {
    thread_observer_->Register(fidlcat_thread()->koid(), this);
    thread_observer_->AddExitBreakpoint(thread, syscall_->name(), return_address_);
  }

  // Restarts the stopped thread. When the breakpoint will be reached (at the
  // end of the syscall), LoadSyscallReturnValue will be called.
  thread->Continue(false);
  return true;
}

void SyscallDecoder::DecodeInputs() {
  if (syscall_->fidl_codec_values_ready()) {
    // We are able to create values from the syscall => create the values.
    //
    invoked_event_ = std::make_shared<InvokedEvent>(timestamp(), fidlcat_thread_, syscall_);
    auto inline_member = syscall_->input_inline_members().begin();
    auto outline_member = syscall_->input_outline_members().begin();
    for (const auto& input : syscall_->inputs()) {
      if (input->InlineValue()) {
        if (input->ConditionsAreTrue(this, Stage::kEntry)) {
          FX_DCHECK(inline_member != syscall_->input_inline_members().end());
          std::unique_ptr<fidl_codec::Value> value = input->GenerateValue(this, Stage::kEntry);
          FX_DCHECK(value != nullptr);
          invoked_event_->AddInlineField(inline_member->get(), std::move(value));
        }
        ++inline_member;
      } else {
        if (input->ConditionsAreTrue(this, Stage::kEntry)) {
          FX_DCHECK(outline_member != syscall_->input_outline_members().end());
          std::unique_ptr<fidl_codec::Value> value = input->GenerateValue(this, Stage::kEntry);
          FX_DCHECK(value != nullptr);
          invoked_event_->AddOutlineField(outline_member->get(), std::move(value));
        }
        ++outline_member;
      }
    }
    if (dispatcher_->needs_stack_frame()) {
      CopyStackFrame(caller_locations(), &invoked_event_->stack_frame());
    }
    if (invoked_event_->NeedsToLoadHandleInfo(&dispatcher_->inference())) {
      fidlcat_thread_->process()->LoadHandleInfo(&dispatcher_->inference());
    }
  }
  // Eventually calls the code before displaying the input (which may invalidate
  // the display).
  if ((syscall_->inputs_decoded_action() == nullptr) ||
      (dispatcher_->*(syscall_->inputs_decoded_action()))(timestamp(), this)) {
    if (invoked_event_ != nullptr) {
      // If we have been able to generate an invoked event, directly call the dispatcher.
      dispatcher_->AddInvokedEvent(invoked_event_);
    } else {
      // Invoked event is not yet available for this syscall.
      use_->SyscallInputsDecoded(this);
    }
  }

  if (syscall_->return_type() == SyscallReturnType::kNoReturn) {
    // We already called Continue in StepToReturnAddress. We don't want to call it twice. We set
    // aborted_ to avoid that.
    aborted_ = true;
    // We don't expect the syscall to return and it doesn't have any output. We can now destroy
    // the decoder.
    Destroy();
  }
}

void SyscallDecoder::LoadSyscallReturnValue() {
  zxdb::Thread* thread = weak_thread_.get();
  if (aborted_ || (thread == nullptr) || (thread->GetStack().size() == 0)) {
    aborted_ = true;
    Destroy();
    return;
  }
  const std::vector<debug_ipc::Register>* general_registers =
      thread->GetStack()[0]->GetRegisterCategorySync(debug_ipc::RegisterCategory::kGeneral);
  FX_DCHECK(general_registers);  // General registers should always be available synchronously.

  debug_ipc::RegisterID result_register = (arch_ == debug_ipc::Arch::kX64)
                                              ? debug_ipc::RegisterID::kX64_rax
                                              : debug_ipc::RegisterID::kARMv8_x0;
  syscall_return_value_ = GetRegisterValue(*general_registers, result_register);

  LoadOutputs();
}

void SyscallDecoder::LoadOutputs() {
  if (error_.type() != DecoderError::Type::kNone) {
    if (pending_request_count_ == 0) {
      use_->SyscallDecodingError(error_, this);
    }
    return;
  }
  for (const auto& output : syscall_->outputs()) {
    if ((output->error_code() == static_cast<zx_status_t>(syscall_return_value_)) &&
        output->ConditionsAreTrue(this, Stage::kExit)) {
      output->Load(this, Stage::kExit);
    }
  }
  if (pending_request_count_ > 0) {
    return;
  }
  if (error_.type() != DecoderError::Type::kNone) {
    use_->SyscallDecodingError(error_, this);
  } else {
    DecodeOutputs();
  }
}

void SyscallDecoder::DecodeOutputs() {
  if (pending_request_count_ > 0) {
    return;
  }
  if (syscall_->fidl_codec_values_ready()) {
    output_event_ = std::make_shared<OutputEvent>(timestamp(), fidlcat_thread_, syscall_,
                                                  syscall_return_value_, invoked_event_);
    auto inline_member = syscall_->output_inline_members().begin();
    auto outline_member = syscall_->output_outline_members().begin();
    for (const auto& output : syscall_->outputs()) {
      if (output->InlineValue()) {
        if ((output->error_code() == static_cast<zx_status_t>(syscall_return_value_)) &&
            (output->ConditionsAreTrue(this, Stage::kExit))) {
          FX_DCHECK(inline_member != syscall_->output_inline_members().end());
          std::unique_ptr<fidl_codec::Value> value = output->GenerateValue(this, Stage::kExit);
          FX_DCHECK(value != nullptr);
          output_event_->AddInlineField(inline_member->get(), std::move(value));
        }
        ++inline_member;
      } else {
        if ((output->error_code() == static_cast<zx_status_t>(syscall_return_value_)) &&
            (output->ConditionsAreTrue(this, Stage::kExit))) {
          FX_DCHECK(outline_member != syscall_->output_outline_members().end());
          std::unique_ptr<fidl_codec::Value> value = output->GenerateValue(this, Stage::kExit);
          FX_DCHECK(value != nullptr);
          output_event_->AddOutlineField(outline_member->get(), std::move(value));
        }
        ++outline_member;
      }
    }
    if (output_event_->NeedsToLoadHandleInfo(&dispatcher_->inference())) {
      fidlcat_thread_->process()->LoadHandleInfo(&dispatcher_->inference());
    }
  }
  if (output_event_ != nullptr) {
    if (syscall_->inference() != nullptr) {
      // Executes the inference associated with the syscall.
      // This is used to infer semantic about handles.
      (dispatcher_->*(syscall_->inference()))(output_event_.get(), semantic());
    }

    // If we have been able to generate an invoked event, directly call the dispatcher.
    dispatcher_->AddOutputEvent(output_event_);
  } else {
    // Output event is not yet available for this syscall.
    use_->SyscallOutputsDecoded(this);
  }

  // Now our job is done, we can destroy the object.
  Destroy();
}

void SyscallDecoder::Destroy() {
  if (pending_request_count_ == 0) {
    dispatcher_->DeleteDecoder(this);
  }
}

void SyscallDisplay::SyscallInputsDecoded(SyscallDecoder* decoder) {
  if (!dispatcher_->display_started()) {
    // The display is not started. Only events can trigger it. We don't have an event so, we have
    // nothing to display.
    return;
  }
  displayed_ = true;
  if (dispatcher_->decode_options().output_mode == OutputMode::kStandard) {
    DisplayInputs(decoder);
  }
}

void SyscallDisplay::DisplayInputs(SyscallDecoder* decoder) {
  // This code will be deleted when we will be able to generate events for all the syscalls.
  const fidl_codec::Colors& colors = dispatcher_->colors();
  std::string line_header =
      colors.green + std::to_string(dispatcher_->GetTime(decoder->timestamp())) + colors.reset +
      ' ' + decoder->fidlcat_thread()->process()->name() + ' ' + colors.red +
      std::to_string(decoder->fidlcat_thread()->process()->koid()) + colors.reset + ':' +
      colors.red + std::to_string(decoder->fidlcat_thread()->koid()) + colors.reset + ' ';
  if (dispatcher_->with_process_info()) {
    os_ << line_header;
  }
  os_ << '\n';

  FidlcatPrinter printer(dispatcher_, decoder->fidlcat_thread()->process(), os_, line_header);

  if (dispatcher_->decode_options().stack_level != kNoStack) {
    // Display caller locations.
    DisplayStackFrame(decoder->caller_locations(), printer);
  }

  // Displays the header and the inline input arguments.
  printer << decoder->syscall()->name() << '(';
  const char* separator = "";
  for (const auto& input : decoder->syscall()->inputs()) {
    if (input->ConditionsAreTrue(decoder, Stage::kEntry)) {
      separator = input->DisplayInline(decoder, Stage::kEntry, separator, printer);
    }
  }
  printer << ")\n";

  {
    // Displays the outline input arguments.
    for (const auto& input : decoder->syscall()->inputs()) {
      if (input->ConditionsAreTrue(decoder, Stage::kEntry)) {
        input->DisplayOutline(decoder, Stage::kEntry, printer);
      }
    }
  }
  dispatcher_->set_last_displayed_syscall(this);
  dispatcher_->clear_last_displayed_event();
}

void SyscallDisplay::SyscallOutputsDecoded(SyscallDecoder* decoder) {
  // This code will be deleted when we will be able to generate events for all the syscalls.
  if (!displayed_ || (dispatcher_->decode_options().output_mode != OutputMode::kStandard)) {
    return;
  }
  if (decoder->syscall()->return_type() != SyscallReturnType::kNoReturn) {
    if (dispatcher_->last_displayed_syscall() != this) {
      // Add a blank line to tell the user that this display is not linked to the
      // previous displayed lines.
      os_ << "\n";
    }
    std::string line_header;
    const fidl_codec::Colors& colors = dispatcher_->colors();
    if (dispatcher_->with_process_info() || (dispatcher_->last_displayed_syscall() != this)) {
      line_header = colors.green + std::to_string(dispatcher_->GetTime(decoder->timestamp())) +
                    colors.reset + ' ' + decoder->fidlcat_thread()->process()->name() + ' ' +
                    colors.red + std::to_string(decoder->fidlcat_thread()->process()->koid()) +
                    colors.reset + ':' + colors.red +
                    std::to_string(decoder->fidlcat_thread()->koid()) + colors.reset + ' ';
    } else {
      line_header = colors.green + std::to_string(dispatcher_->GetTime(decoder->timestamp())) +
                    colors.reset + ' ';
    }
    FidlcatPrinter printer(dispatcher_, decoder->fidlcat_thread()->process(), os_, line_header);
    // Displays the returned value.
    printer << "  -> ";
    switch (decoder->syscall()->return_type()) {
      case SyscallReturnType::kNoReturn:
      case SyscallReturnType::kVoid:
        break;
      case SyscallReturnType::kStatus:
        printer.DisplayStatus(static_cast<zx_status_t>(decoder->syscall_return_value()));
        break;
      case SyscallReturnType::kTicks:
        printer << fidl_codec::Green << "ticks" << fidl_codec::ResetColor << ": "
                << fidl_codec::Blue << static_cast<uint64_t>(decoder->syscall_return_value())
                << fidl_codec::ResetColor;
        break;
      case SyscallReturnType::kTime:
        printer << fidl_codec::Green << "time" << fidl_codec::ResetColor << ": "
                << DisplayTime(static_cast<zx_time_t>(decoder->syscall_return_value()));
        break;
      case SyscallReturnType::kUint32:
        printer << fidl_codec::Blue << static_cast<uint32_t>(decoder->syscall_return_value())
                << fidl_codec::ResetColor;
        break;
      case SyscallReturnType::kUint64:
        printer << fidl_codec::Blue << static_cast<uint64_t>(decoder->syscall_return_value())
                << fidl_codec::ResetColor;
        break;
    }
    // And the inline output arguments (if any).
    const char* separator = " (";
    for (const auto& output : decoder->syscall()->outputs()) {
      if ((output->error_code() == static_cast<zx_status_t>(decoder->syscall_return_value())) &&
          output->ConditionsAreTrue(decoder, Stage::kExit)) {
        separator = output->DisplayInline(decoder, Stage::kExit, separator, printer);
      }
    }
    if (std::string(" (") != separator) {
      printer << ')';
    }
    printer << '\n';
    {
      fidl_codec::Indent indent(printer);
      // Displays the outline output arguments.
      for (const auto& output : decoder->syscall()->outputs()) {
        if ((output->error_code() == static_cast<zx_status_t>(decoder->syscall_return_value())) &&
            output->ConditionsAreTrue(decoder, Stage::kExit)) {
          output->DisplayOutline(decoder, Stage::kExit, printer);
        }
      }
    }

    dispatcher_->set_last_displayed_syscall(this);
    dispatcher_->clear_last_displayed_event();
  }
}

void SyscallDisplay::SyscallDecodingError(const DecoderError& error, SyscallDecoder* decoder) {
  std::string message = error.message();
  size_t pos = 0;
  for (;;) {
    size_t end = message.find('\n', pos);
    const fidl_codec::Colors& colors = dispatcher_->colors();
    os_ << decoder->fidlcat_thread()->process()->name() << ' ' << colors.red
        << decoder->fidlcat_thread()->process()->koid() << colors.reset << ':' << colors.red
        << decoder->fidlcat_thread()->koid() << colors.reset << ' ' << decoder->syscall()->name()
        << ": " << colors.red << error.message().substr(pos, end) << colors.reset << '\n';
    if (end == std::string::npos) {
      break;
    }
    pos = end + 1;
  }
  os_ << '\n';
  decoder->Destroy();
}

void SyscallCompare::SyscallInputsDecoded(SyscallDecoder* decoder) {
  os_.clear();
  os_.str("");
  SyscallDisplay::SyscallInputsDecoded(decoder);
  comparator_->CompareInput(os_.str(), decoder->fidlcat_thread()->process()->name(),
                            decoder->fidlcat_thread()->process()->koid(),
                            decoder->fidlcat_thread()->koid());
}

void SyscallCompare::SyscallOutputsDecoded(SyscallDecoder* decoder) {
  os_.clear();
  os_.str("");
  SyscallDisplay::SyscallOutputsDecoded(decoder);
  if (decoder->syscall()->return_type() != SyscallReturnType::kNoReturn) {
    comparator_->CompareOutput(os_.str(), decoder->fidlcat_thread()->process()->name(),
                               decoder->fidlcat_thread()->process()->koid(),
                               decoder->fidlcat_thread()->koid());
  }
}

void SyscallCompare::SyscallDecodingError(const DecoderError& error, SyscallDecoder* decoder) {
  os_.clear();
  os_.str("");
  SyscallDisplay::SyscallDecodingError(error, decoder);
  comparator_->DecodingError(os_.str());
}

}  // namespace fidlcat