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

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/Target.h"

using namespace lldb;
using namespace lldb_private;

//----------------------------------------------------------------------
// ThreadPlanStepInstruction: Step over the current instruction
//----------------------------------------------------------------------

ThreadPlanStepInstruction::ThreadPlanStepInstruction(Thread &thread,
                                                     bool step_over,
                                                     bool stop_other_threads,
                                                     Vote stop_vote,
                                                     Vote run_vote)
    : ThreadPlan(ThreadPlan::eKindStepInstruction,
                 "Step over single instruction", thread, stop_vote, run_vote),
      m_instruction_addr(0), m_stop_other_threads(stop_other_threads),
      m_step_over(step_over) {
  m_takes_iteration_count = true;
  SetUpState();
}

ThreadPlanStepInstruction::~ThreadPlanStepInstruction() = default;

void ThreadPlanStepInstruction::SetUpState() {
  m_instruction_addr = m_thread.GetRegisterContext()->GetPC(0);
  StackFrameSP start_frame_sp(m_thread.GetStackFrameAtIndex(0));
  m_stack_id = start_frame_sp->GetStackID();

  m_start_has_symbol =
      start_frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol != nullptr;

  StackFrameSP parent_frame_sp = m_thread.GetStackFrameAtIndex(1);
  if (parent_frame_sp)
    m_parent_frame_id = parent_frame_sp->GetStackID();
}

void ThreadPlanStepInstruction::GetDescription(Stream *s,
                                               lldb::DescriptionLevel level) {
  if (level == lldb::eDescriptionLevelBrief) {
    if (m_step_over)
      s->Printf("instruction step over");
    else
      s->Printf("instruction step into");
  } else {
    s->Printf("Stepping one instruction past ");
    s->Address(m_instruction_addr, sizeof(addr_t));
    if (!m_start_has_symbol)
      s->Printf(" which has no symbol");

    if (m_step_over)
      s->Printf(" stepping over calls");
    else
      s->Printf(" stepping into calls");
  }
}

bool ThreadPlanStepInstruction::ValidatePlan(Stream *error) {
  // Since we read the instruction we're stepping over from the thread,
  // this plan will always work.
  return true;
}

bool ThreadPlanStepInstruction::DoPlanExplainsStop(Event *event_ptr) {
  StopInfoSP stop_info_sp = GetPrivateStopInfo();
  if (stop_info_sp) {
    StopReason reason = stop_info_sp->GetStopReason();
    return (reason == eStopReasonTrace || reason == eStopReasonNone);
  }
  return false;
}

bool ThreadPlanStepInstruction::IsPlanStale() {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
  StackID cur_frame_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
  if (cur_frame_id == m_stack_id) {
    return (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr);
  } else if (cur_frame_id < m_stack_id) {
    // If the current frame is younger than the start frame and we are stepping
    // over, then we need to continue,
    // but if we are doing just one step, we're done.
    return !m_step_over;
  } else {
    if (log) {
      log->Printf("ThreadPlanStepInstruction::IsPlanStale - Current frame is "
                  "older than start frame, plan is stale.");
    }
    return true;
  }
}

bool ThreadPlanStepInstruction::ShouldStop(Event *event_ptr) {
  if (m_step_over) {
    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));

    StackFrameSP cur_frame_sp = m_thread.GetStackFrameAtIndex(0);
    if (!cur_frame_sp) {
      if (log)
        log->Printf(
            "ThreadPlanStepInstruction couldn't get the 0th frame, stopping.");
      SetPlanComplete();
      return true;
    }

    StackID cur_frame_zero_id = cur_frame_sp->GetStackID();

    if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
      if (m_thread.GetRegisterContext()->GetPC(0) != m_instruction_addr) {
        if (--m_iteration_count <= 0) {
          SetPlanComplete();
          return true;
        } else {
          // We are still stepping, reset the start pc, and in case we've
          // stepped out,
          // reset the current stack id.
          SetUpState();
          return false;
        }
      } else
        return false;
    } else {
      // We've stepped in, step back out again:
      StackFrame *return_frame = m_thread.GetStackFrameAtIndex(1).get();
      if (return_frame) {
        if (return_frame->GetStackID() != m_parent_frame_id ||
            m_start_has_symbol) {
          // next-instruction shouldn't step out of inlined functions.  But we
          // may have stepped into a
          // real function that starts with an inlined function, and we do want
          // to step out of that...

          if (cur_frame_sp->IsInlined()) {
            StackFrameSP parent_frame_sp =
                m_thread.GetFrameWithStackID(m_stack_id);

            if (parent_frame_sp &&
                parent_frame_sp->GetConcreteFrameIndex() ==
                    cur_frame_sp->GetConcreteFrameIndex()) {
              SetPlanComplete();
              if (log) {
                log->Printf("Frame we stepped into is inlined into the frame "
                            "we were stepping from, stopping.");
              }
              return true;
            }
          }

          if (log) {
            StreamString s;
            s.PutCString("Stepped in to: ");
            addr_t stop_addr =
                m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
            s.Address(stop_addr, m_thread.CalculateTarget()
                                     ->GetArchitecture()
                                     .GetAddressByteSize());
            s.PutCString(" stepping out to: ");
            addr_t return_addr = return_frame->GetRegisterContext()->GetPC();
            s.Address(return_addr, m_thread.CalculateTarget()
                                       ->GetArchitecture()
                                       .GetAddressByteSize());
            log->Printf("%s.", s.GetData());
          }

          // StepInstruction should probably have the tri-state RunMode, but for
          // now it is safer to
          // run others.
          const bool stop_others = false;
          m_thread.QueueThreadPlanForStepOutNoShouldStop(
              false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0);
          return false;
        } else {
          if (log) {
            log->PutCString(
                "The stack id we are stepping in changed, but our parent frame "
                "did not when stepping from code with no symbols.  "
                "We are probably just confused about where we are, stopping.");
          }
          SetPlanComplete();
          return true;
        }
      } else {
        if (log)
          log->Printf("Could not find previous frame, stopping.");
        SetPlanComplete();
        return true;
      }
    }
  } else {
    lldb::addr_t pc_addr = m_thread.GetRegisterContext()->GetPC(0);
    if (pc_addr != m_instruction_addr) {
      if (--m_iteration_count <= 0) {
        SetPlanComplete();
        return true;
      } else {
        // We are still stepping, reset the start pc, and in case we've stepped
        // in or out,
        // reset the current stack id.
        SetUpState();
        return false;
      }
    } else
      return false;
  }
}

bool ThreadPlanStepInstruction::StopOthers() { return m_stop_other_threads; }

StateType ThreadPlanStepInstruction::GetPlanRunState() {
  return eStateStepping;
}

bool ThreadPlanStepInstruction::WillStop() { return true; }

bool ThreadPlanStepInstruction::MischiefManaged() {
  if (IsPlanComplete()) {
    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
    if (log)
      log->Printf("Completed single instruction step plan.");
    ThreadPlan::MischiefManaged();
    return true;
  } else {
    return false;
  }
}