//===------------------------- UnwindCursor.hpp ---------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//
// C++ interface to lower levels of libuwind
//===----------------------------------------------------------------------===//

#ifndef __UNWINDCURSOR_HPP__
#define __UNWINDCURSOR_HPP__

#include <stdint.h>
#include <stdlib.h>
#include <pthread.h>

#include "AddressSpace.hpp"
#include "DwarfInstructions.hpp"
#include "Registers.hpp"

namespace _Unwind {

template <typename A, typename R> class UnwindCursor {
public:
 UnwindCursor(R &regs, A &as)
     : fRegisters(regs), fAddressSpace(as), fUnwindInfoMissing(false),
       fIsSignalFrame(false) {
   memset(&fInfo, 0, sizeof(fInfo));
 }

 uint64_t getIP() const { return fRegisters.getIP(); }

 void setIP(uint64_t value) { return fRegisters.setIP(value); }

 uint64_t getSP() const { return fRegisters.getSP(); }

 void setSP(uint64_t value) { return fRegisters.setSP(value); }

 bool validReg(int regNum) { return fRegisters.validRegister(regNum); }

 uint64_t getReg(int regNum) { return fRegisters.getRegister(regNum); }

 void setReg(int regNum, uint64_t value) {
   fRegisters.setRegister(regNum, value);
 }

 step_result step() {
   // Bottom of stack is defined as having no more unwind info.
   if (fUnwindInfoMissing)
     return UNW_STEP_END;

   // Apply unwinding to register set.
   switch (this->stepWithDwarfFDE()) {
   case UNW_STEP_FAILED:
     return UNW_STEP_FAILED;
   case UNW_STEP_END:
     return UNW_STEP_END;
   case UNW_STEP_SUCCESS:
     this->setInfoBasedOnIPRegister(true);
     if (fUnwindInfoMissing)
       return UNW_STEP_END;
     return UNW_STEP_SUCCESS;
   }
   __builtin_unreachable();
 }

 void getInfo(unw_proc_info_t *info) { *info = fInfo; }

 bool isSignalFrame() { return fIsSignalFrame; }
 void setInfoBasedOnIPRegister(bool isReturnAddress = false);

 void jumpto() { fRegisters.jumpto(); }

private:
 typedef typename A::pint_t pint_t;
 typedef uint32_t EncodedUnwindInfo;

 bool getInfoFromDwarfSection(pint_t, pint_t, uint32_t, uint32_t);

 step_result stepWithDwarfFDE() {
   return DwarfInstructions<A, R>::stepWithDwarf(
       fAddressSpace, this->getIP(), fInfo.unwind_info, fRegisters, &fInfo);
 }

 unw_proc_info_t fInfo;
 R fRegisters;
 A &fAddressSpace;
 bool fUnwindInfoMissing;
 bool fIsSignalFrame;
};

template <typename A, typename R>
void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
 pint_t pc = this->getIP();

 // If the last line of a function is a "throw", the compiler sometimes
 // emits no instructions after the call to __cxa_throw.  This means
 // the return address is actually the start of the next function.
 // To disambiguate this, back up the PC when we know it is a return
 // address.
 if (isReturnAddress)
   --pc;

 pint_t fdeStart, data_base;
 if (!fAddressSpace.findFDE(pc, fdeStart, data_base)) {
   fUnwindInfoMissing = true;
   return;
 }
 fInfo.data_base = data_base;

 typename CFI_Parser<A, R>::FDE_Info fdeInfo;
 typename CFI_Parser<A, R>::CIE_Info cieInfo;
 CFI_Parser<A, R>::decodeFDE(fAddressSpace, fdeStart, &fdeInfo, &cieInfo,
                             &fInfo);
 if (pc < fdeInfo.pcStart || pc > fdeInfo.pcEnd) {
   fUnwindInfoMissing = true;
   return;
 }
 fInfo.start_ip = fdeInfo.pcStart;

 typename CFI_Parser<A, R>::PrologInfo prolog;
 if (!CFI_Parser<A, R>::parseFDEInstructions(fAddressSpace, fdeInfo, cieInfo,
                                             pc, &prolog, &fInfo)) {
   fUnwindInfoMissing = true;
   return;
 }
 // Save off parsed FDE info
 fInfo.end_ip = fdeInfo.pcEnd;
 fInfo.lsda = fdeInfo.lsda;
 fInfo.handler = cieInfo.personality;
 fInfo.extra_args = prolog.spExtraArgSize;
 fInfo.unwind_info = fdeInfo.fdeStart;
}

}; // namespace _Unwind

#endif // __UNWINDCURSOR_HPP__