contrib/llvm/tools/lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

   1 //===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "UnwindAssemblyInstEmulation.h"
  11
  12 #include "lldb/Core/Address.h"
  13 #include "lldb/Core/ArchSpec.h"
  14 #include "lldb/Core/DataBufferHeap.h"
  15 #include "lldb/Core/DataExtractor.h"
  16 #include "lldb/Core/Disassembler.h"
  17 #include "lldb/Core/Error.h"
  18 #include "lldb/Core/Log.h"
  19 #include "lldb/Core/PluginManager.h"
  20 #include "lldb/Core/StreamString.h"
  21 #include "lldb/Target/ExecutionContext.h"
  22 #include "lldb/Target/Process.h"
  23 #include "lldb/Target/Thread.h"
  24 #include "lldb/Target/Target.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29
  30
  31 //-----------------------------------------------------------------------------------------------
  32 //  UnwindAssemblyInstEmulation method definitions
  33 //-----------------------------------------------------------------------------------------------
  34
  35 bool
  36 UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly (AddressRange& range,
  37                                                                    Thread& thread,
  38                                                                    UnwindPlan& unwind_plan)
  39 {
  40     if (range.GetByteSize() > 0 &&
  41         range.GetBaseAddress().IsValid() &&
  42         m_inst_emulator_ap.get())
  43     {
  44
  45         // The the instruction emulation subclass setup the unwind plan for the
  46         // first instruction.
  47         m_inst_emulator_ap->CreateFunctionEntryUnwind (unwind_plan);
  48
  49         // CreateFunctionEntryUnwind should have created the first row. If it
  50         // doesn't, then we are done.
  51         if (unwind_plan.GetRowCount() == 0)
  52             return false;
  53
  54         ExecutionContext exe_ctx;
  55         thread.CalculateExecutionContext(exe_ctx);
  56         const bool prefer_file_cache = true;
  57         DisassemblerSP disasm_sp (Disassembler::DisassembleRange (m_arch,
  58                                                                   NULL,
  59                                                                   NULL,
  60                                                                   exe_ctx,
  61                                                                   range,
  62                                                                   prefer_file_cache));
  63
  64         Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
  65
  66         if (disasm_sp)
  67         {
  68
  69             m_range_ptr = &range;
  70             m_thread_ptr = &thread;
  71             m_unwind_plan_ptr = &unwind_plan;
  72
  73             const uint32_t addr_byte_size = m_arch.GetAddressByteSize();
  74             const bool show_address = true;
  75             const bool show_bytes = true;
  76             m_inst_emulator_ap->GetRegisterInfo (unwind_plan.GetRegisterKind(),
  77                                                  unwind_plan.GetInitialCFARegister(),
  78                                                  m_cfa_reg_info);
  79
  80             m_fp_is_cfa = false;
  81             m_register_values.clear();
  82             m_pushed_regs.clear();
  83
  84             // Initialize the CFA with a known value. In the 32 bit case
  85             // it will be 0x80000000, and in the 64 bit case 0x8000000000000000.
  86             // We use the address byte size to be safe for any future addresss sizes
  87             m_initial_sp = (1ull << ((addr_byte_size * 8) - 1));
  88             RegisterValue cfa_reg_value;
  89             cfa_reg_value.SetUInt (m_initial_sp, m_cfa_reg_info.byte_size);
  90             SetRegisterValue (m_cfa_reg_info, cfa_reg_value);
  91
  92             const InstructionList &inst_list = disasm_sp->GetInstructionList ();
  93             const size_t num_instructions = inst_list.GetSize();
  94
  95             if (num_instructions > 0)
  96             {
  97                 Instruction *inst = inst_list.GetInstructionAtIndex (0).get();
  98                 const addr_t base_addr = inst->GetAddress().GetFileAddress();
  99
 100                 // Make a copy of the current instruction Row and save it in m_curr_row
 101                 // so we can add updates as we process the instructions.
 102                 UnwindPlan::RowSP last_row = unwind_plan.GetLastRow();
 103                 UnwindPlan::Row *newrow = new UnwindPlan::Row;
 104                 if (last_row.get())
 105                     *newrow = *last_row.get();
 106                 m_curr_row.reset(newrow);
 107
 108                 // Once we've seen the initial prologue instructions complete, save a
 109                 // copy of the CFI at that point into prologue_completed_row for possible
 110                 // use later.
 111                 int instructions_since_last_prologue_insn = 0;     // # of insns since last CFI was update
 112
 113                 bool reinstate_prologue_next_instruction = false;  // Next iteration, re-install the prologue row of CFI
 114
 115                 bool last_instruction_restored_return_addr_reg = false;  // re-install the prologue row of CFI if the next instruction is a branch immediate
 116
 117                 bool return_address_register_has_been_saved = false; // if we've seen the ra register get saved yet
 118
 119                 UnwindPlan::RowSP prologue_completed_row;          // copy of prologue row of CFI
 120
 121                 // cache the pc register number (in whatever register numbering this UnwindPlan uses) for
 122                 // quick reference during instruction parsing.
 123                 uint32_t pc_reg_num = LLDB_INVALID_REGNUM;
 124                 RegisterInfo pc_reg_info;
 125                 if (m_inst_emulator_ap->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc_reg_info))
 126                     pc_reg_num = pc_reg_info.kinds[unwind_plan.GetRegisterKind()];
 127                 else
 128                     pc_reg_num = LLDB_INVALID_REGNUM;
 129
 130                 // cache the return address register number (in whatever register numbering this UnwindPlan uses) for
 131                 // quick reference during instruction parsing.
 132                 uint32_t ra_reg_num = LLDB_INVALID_REGNUM;
 133                 RegisterInfo ra_reg_info;
 134                 if (m_inst_emulator_ap->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, ra_reg_info))
 135                     ra_reg_num = ra_reg_info.kinds[unwind_plan.GetRegisterKind()];
 136                 else
 137                     ra_reg_num = LLDB_INVALID_REGNUM;
 138
 139                 for (size_t idx=0; idx<num_instructions; ++idx)
 140                 {
 141                     m_curr_row_modified = false;
 142                     m_curr_insn_restored_a_register = false;
 143                     inst = inst_list.GetInstructionAtIndex (idx).get();
 144                     if (inst)
 145                     {
 146                         if (log && log->GetVerbose ())
 147                         {
 148                             StreamString strm;
 149                             inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize (), show_address, show_bytes, NULL);
 150                             log->PutCString (strm.GetData());
 151                         }
 152
 153                         m_inst_emulator_ap->SetInstruction (inst->GetOpcode(),
 154                                                             inst->GetAddress(),
 155                                                             exe_ctx.GetTargetPtr());
 156
 157                         m_inst_emulator_ap->EvaluateInstruction (eEmulateInstructionOptionIgnoreConditions);
 158
 159                         // Were there any changes to the CFI while evaluating this instruction?
 160                         if (m_curr_row_modified)
 161                         {
 162                             reinstate_prologue_next_instruction = false;
 163                             m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() + inst->GetOpcode().GetByteSize() - base_addr);
 164                             // Append the new row
 165                             unwind_plan.AppendRow (m_curr_row);
 166
 167                             // Allocate a new Row for m_curr_row, copy the current state into it
 168                             UnwindPlan::Row *newrow = new UnwindPlan::Row;
 169                             *newrow = *m_curr_row.get();
 170                             m_curr_row.reset(newrow);
 171
 172                             // If m_curr_insn_restored_a_register == true, we're looking at an epilogue instruction.
 173                             // Set instructions_since_last_prologue_insn to a very high number so we don't append
 174                             // any of these epilogue instructions to our prologue_complete row.
 175                             if (m_curr_insn_restored_a_register == false && instructions_since_last_prologue_insn < 8)
 176                               instructions_since_last_prologue_insn = 0;
 177                             else
 178                               instructions_since_last_prologue_insn = 99;
 179
 180                             UnwindPlan::Row::RegisterLocation pc_regloc;
 181                             UnwindPlan::Row::RegisterLocation ra_regloc;
 182
 183                             // While parsing the instructions of this function, if we've ever
 184                             // seen the return address register (aka lr on arm) in a non-IsSame() state,
 185                             // it has been saved on the stack.  If it's evern back to IsSame(), we've
 186                             // executed an epilogue.
 187                             if (ra_reg_num != LLDB_INVALID_REGNUM
 188                                 && m_curr_row->GetRegisterInfo (ra_reg_num, ra_regloc)
 189                                 && !ra_regloc.IsSame())
 190                             {
 191                                 return_address_register_has_been_saved = true;
 192                             }
 193
 194                             // If the caller's pc is "same", we've just executed an epilogue and we return to the caller
 195                             // after this instruction completes executing.
 196                             // If there are any instructions past this, there must have been flow control over this
 197                             // epilogue so we'll reinstate the original prologue setup instructions.
 198                             if (prologue_completed_row.get()
 199                                 && pc_reg_num != LLDB_INVALID_REGNUM
 200                                 && m_curr_row->GetRegisterInfo (pc_reg_num, pc_regloc)
 201                                 && pc_regloc.IsSame())
 202                             {
 203                                 if (log && log->GetVerbose())
 204                                     log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- pc is <same>, restore prologue instructions.");
 205                                 reinstate_prologue_next_instruction = true;
 206                             }
 207                             else if (prologue_completed_row.get()
 208                                      && return_address_register_has_been_saved
 209                                      && ra_reg_num != LLDB_INVALID_REGNUM
 210                                      && m_curr_row->GetRegisterInfo (ra_reg_num, ra_regloc)
 211                                      && ra_regloc.IsSame())
 212                             {
 213                                 if (log && log->GetVerbose())
 214                                     log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- lr is <same>, restore prologue instruction if the next instruction is a branch immediate.");
 215                                 last_instruction_restored_return_addr_reg = true;
 216                             }
 217                         }
 218                         else
 219                         {
 220                             // If the previous instruction was a return-to-caller (epilogue), and we're still executing
 221                             // instructions in this function, there must be a code path that jumps over that epilogue.
 222                             // Also detect the case where we epilogue & branch imm to another function (tail-call opt)
 223                             // instead of a normal pop lr-into-pc exit.
 224                             // Reinstate the frame setup from the prologue.
 225                             if (reinstate_prologue_next_instruction
 226                                 || (m_curr_insn_is_branch_immediate && last_instruction_restored_return_addr_reg))
 227                             {
 228                                 if (log && log->GetVerbose())
 229                                     log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- Reinstating prologue instruction set");
 230                                 UnwindPlan::Row *newrow = new UnwindPlan::Row;
 231                                 *newrow = *prologue_completed_row.get();
 232                                 m_curr_row.reset(newrow);
 233                                 m_curr_row->SetOffset (inst->GetAddress().GetFileAddress() + inst->GetOpcode().GetByteSize() - base_addr);
 234                                 unwind_plan.AppendRow(m_curr_row);
 235
 236                                 newrow = new UnwindPlan::Row;
 237                                 *newrow = *m_curr_row.get();
 238                                 m_curr_row.reset(newrow);
 239
 240                                 reinstate_prologue_next_instruction = false;
 241                                 last_instruction_restored_return_addr_reg = false;
 242                                 m_curr_insn_is_branch_immediate = false;
 243                             }
 244
 245                             // clear both of these if either one wasn't set
 246                             if (last_instruction_restored_return_addr_reg)
 247                             {
 248                                 last_instruction_restored_return_addr_reg = false;
 249                             }
 250                             if (m_curr_insn_is_branch_immediate)
 251                             {
 252                                 m_curr_insn_is_branch_immediate = false;
 253                             }
 254
 255                             // Stop updating the prologue instructions if we've seen 8 non-prologue instructions
 256                             // in a row.
 257                             if (instructions_since_last_prologue_insn++ < 8)
 258                             {
 259                                 UnwindPlan::Row *newrow = new UnwindPlan::Row;
 260                                 *newrow = *m_curr_row.get();
 261                                 prologue_completed_row.reset(newrow);
 262                                 if (log && log->GetVerbose())
 263                                     log->Printf("UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly -- saving a copy of the current row as the prologue row.");
 264                             }
 265                         }
 266                     }
 267                 }
 268             }
 269             // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions.
 270             // I'll fix that but for now, just clear the list and it will go away nicely.
 271             disasm_sp->GetInstructionList().Clear();
 272         }
 273
 274         if (log && log->GetVerbose ())
 275         {
 276             StreamString strm;
 277             lldb::addr_t base_addr = range.GetBaseAddress().GetLoadAddress(thread.CalculateTarget().get());
 278             strm.Printf ("Resulting unwind rows for [0x%" PRIx64 " - 0x%" PRIx64 "):", base_addr, base_addr + range.GetByteSize());
 279             unwind_plan.Dump(strm, &thread, base_addr);
 280             log->PutCString (strm.GetData());
 281         }
 282         return unwind_plan.GetRowCount() > 0;
 283     }
 284     return false;
 285 }
 286
 287 bool
 288 UnwindAssemblyInstEmulation::GetFastUnwindPlan (AddressRange& func,
 289                                                 Thread& thread,
 290                                                 UnwindPlan &unwind_plan)
 291 {
 292     return false;
 293 }
 294
 295 bool
 296 UnwindAssemblyInstEmulation::FirstNonPrologueInsn (AddressRange& func,
 297                                                    const ExecutionContext &exe_ctx,
 298                                                    Address& first_non_prologue_insn)
 299 {
 300     return false;
 301 }
 302
 303 UnwindAssembly *
 304 UnwindAssemblyInstEmulation::CreateInstance (const ArchSpec &arch)
 305 {
 306     std::unique_ptr<EmulateInstruction> inst_emulator_ap (EmulateInstruction::FindPlugin (arch, eInstructionTypePrologueEpilogue, NULL));
 307     // Make sure that all prologue instructions are handled
 308     if (inst_emulator_ap.get())
 309         return new UnwindAssemblyInstEmulation (arch, inst_emulator_ap.release());
 310     return NULL;
 311 }
 312
 313
 314 //------------------------------------------------------------------
 315 // PluginInterface protocol in UnwindAssemblyParser_x86
 316 //------------------------------------------------------------------
 317 ConstString
 318 UnwindAssemblyInstEmulation::GetPluginName()
 319 {
 320     return GetPluginNameStatic();
 321 }
 322
 323 uint32_t
 324 UnwindAssemblyInstEmulation::GetPluginVersion()
 325 {
 326     return 1;
 327 }
 328
 329 void
 330 UnwindAssemblyInstEmulation::Initialize()
 331 {
 332     PluginManager::RegisterPlugin (GetPluginNameStatic(),
 333                                    GetPluginDescriptionStatic(),
 334                                    CreateInstance);
 335 }
 336
 337 void
 338 UnwindAssemblyInstEmulation::Terminate()
 339 {
 340     PluginManager::UnregisterPlugin (CreateInstance);
 341 }
 342
 343
 344 ConstString
 345 UnwindAssemblyInstEmulation::GetPluginNameStatic()
 346 {
 347     static ConstString g_name("inst-emulation");
 348     return g_name;
 349 }
 350
 351 const char *
 352 UnwindAssemblyInstEmulation::GetPluginDescriptionStatic()
 353 {
 354     return "Instruction emulation based unwind information.";
 355 }
 356
 357
 358 uint64_t
 359 UnwindAssemblyInstEmulation::MakeRegisterKindValuePair (const RegisterInfo &reg_info)
 360 {
 361     uint32_t reg_kind, reg_num;
 362     if (EmulateInstruction::GetBestRegisterKindAndNumber (&reg_info, reg_kind, reg_num))
 363         return (uint64_t)reg_kind << 24 | reg_num;
 364     return 0ull;
 365 }
 366
 367 void
 368 UnwindAssemblyInstEmulation::SetRegisterValue (const RegisterInfo &reg_info, const RegisterValue &reg_value)
 369 {
 370     m_register_values[MakeRegisterKindValuePair (reg_info)] = reg_value;
 371 }
 372
 373 bool
 374 UnwindAssemblyInstEmulation::GetRegisterValue (const RegisterInfo &reg_info, RegisterValue &reg_value)
 375 {
 376     const uint64_t reg_id = MakeRegisterKindValuePair (reg_info);
 377     RegisterValueMap::const_iterator pos = m_register_values.find(reg_id);
 378     if (pos != m_register_values.end())
 379     {
 380         reg_value = pos->second;
 381         return true; // We had a real value that comes from an opcode that wrote
 382                      // to it...
 383     }
 384     // We are making up a value that is recognizable...
 385     reg_value.SetUInt(reg_id, reg_info.byte_size);
 386     return false;
 387 }
 388
 389
 390 size_t
 391 UnwindAssemblyInstEmulation::ReadMemory (EmulateInstruction *instruction,
 392                                          void *baton,
 393                                          const EmulateInstruction::Context &context,
 394                                          lldb::addr_t addr,
 395                                          void *dst,
 396                                          size_t dst_len)
 397 {
 398     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 399
 400     if (log && log->GetVerbose ())
 401     {
 402         StreamString strm;
 403         strm.Printf ("UnwindAssemblyInstEmulation::ReadMemory    (addr = 0x%16.16" PRIx64 ", dst = %p, dst_len = %" PRIu64 ", context = ",
 404                      addr,
 405                      dst,
 406                      (uint64_t)dst_len);
 407         context.Dump(strm, instruction);
 408         log->PutCString (strm.GetData ());
 409     }
 410     memset (dst, 0, dst_len);
 411     return dst_len;
 412 }
 413
 414 size_t
 415 UnwindAssemblyInstEmulation::WriteMemory (EmulateInstruction *instruction,
 416                                           void *baton,
 417                                           const EmulateInstruction::Context &context,
 418                                           lldb::addr_t addr,
 419                                           const void *dst,
 420                                           size_t dst_len)
 421 {
 422     if (baton && dst && dst_len)
 423         return ((UnwindAssemblyInstEmulation *)baton)->WriteMemory (instruction, context, addr, dst, dst_len);
 424     return 0;
 425 }
 426
 427 size_t
 428 UnwindAssemblyInstEmulation::WriteMemory (EmulateInstruction *instruction,
 429                                           const EmulateInstruction::Context &context,
 430                                           lldb::addr_t addr,
 431                                           const void *dst,
 432                                           size_t dst_len)
 433 {
 434     DataExtractor data (dst,
 435                         dst_len,
 436                         instruction->GetArchitecture ().GetByteOrder(),
 437                         instruction->GetArchitecture ().GetAddressByteSize());
 438
 439     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 440
 441     if (log && log->GetVerbose ())
 442     {
 443         StreamString strm;
 444
 445         strm.PutCString ("UnwindAssemblyInstEmulation::WriteMemory   (");
 446         data.Dump(&strm, 0, eFormatBytes, 1, dst_len, UINT32_MAX, addr, 0, 0);
 447         strm.PutCString (", context = ");
 448         context.Dump(strm, instruction);
 449         log->PutCString (strm.GetData());
 450     }
 451
 452     const bool can_replace = true;
 453     const bool cant_replace = false;
 454
 455     switch (context.type)
 456     {
 457         default:
 458         case EmulateInstruction::eContextInvalid:
 459         case EmulateInstruction::eContextReadOpcode:
 460         case EmulateInstruction::eContextImmediate:
 461         case EmulateInstruction::eContextAdjustBaseRegister:
 462         case EmulateInstruction::eContextRegisterPlusOffset:
 463         case EmulateInstruction::eContextAdjustPC:
 464         case EmulateInstruction::eContextRegisterStore:
 465         case EmulateInstruction::eContextRegisterLoad:
 466         case EmulateInstruction::eContextRelativeBranchImmediate:
 467         case EmulateInstruction::eContextAbsoluteBranchRegister:
 468         case EmulateInstruction::eContextSupervisorCall:
 469         case EmulateInstruction::eContextTableBranchReadMemory:
 470         case EmulateInstruction::eContextWriteRegisterRandomBits:
 471         case EmulateInstruction::eContextWriteMemoryRandomBits:
 472         case EmulateInstruction::eContextArithmetic:
 473         case EmulateInstruction::eContextAdvancePC:
 474         case EmulateInstruction::eContextReturnFromException:
 475         case EmulateInstruction::eContextPopRegisterOffStack:
 476         case EmulateInstruction::eContextAdjustStackPointer:
 477             break;
 478
 479         case EmulateInstruction::eContextPushRegisterOnStack:
 480             {
 481                 uint32_t reg_num = LLDB_INVALID_REGNUM;
 482                 bool is_return_address_reg = false;
 483                 const uint32_t unwind_reg_kind = m_unwind_plan_ptr->GetRegisterKind();
 484                 if (context.info_type == EmulateInstruction::eInfoTypeRegisterToRegisterPlusOffset)
 485                 {
 486                     reg_num = context.info.RegisterToRegisterPlusOffset.data_reg.kinds[unwind_reg_kind];
 487                     if (context.info.RegisterToRegisterPlusOffset.data_reg.kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_RA)
 488                         is_return_address_reg = true;
 489                 }
 490                 else
 491                 {
 492                     assert (!"unhandled case, add code to handle this!");
 493                 }
 494
 495                 if (reg_num != LLDB_INVALID_REGNUM)
 496                 {
 497                     if (m_pushed_regs.find (reg_num) == m_pushed_regs.end())
 498                     {
 499                         m_pushed_regs[reg_num] = addr;
 500                         const int32_t offset = addr - m_initial_sp;
 501                         m_curr_row->SetRegisterLocationToAtCFAPlusOffset (reg_num, offset, cant_replace);
 502                         m_curr_row_modified = true;
 503                         if (is_return_address_reg)
 504                         {
 505                             // This push was pushing the return address register,
 506                             // so this is also how we will unwind the PC...
 507                             RegisterInfo pc_reg_info;
 508                             if (instruction->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc_reg_info))
 509                             {
 510                                 uint32_t pc_reg_num = pc_reg_info.kinds[unwind_reg_kind];
 511                                 if (pc_reg_num != LLDB_INVALID_REGNUM)
 512                                 {
 513                                     m_curr_row->SetRegisterLocationToAtCFAPlusOffset (pc_reg_num, offset, can_replace);
 514                                     m_curr_row_modified = true;
 515                                 }
 516                             }
 517                         }
 518                     }
 519                 }
 520             }
 521             break;
 522
 523     }
 524
 525     return dst_len;
 526 }
 527
 528 bool
 529 UnwindAssemblyInstEmulation::ReadRegister (EmulateInstruction *instruction,
 530                                            void *baton,
 531                                            const RegisterInfo *reg_info,
 532                                            RegisterValue &reg_value)
 533 {
 534
 535     if (baton && reg_info)
 536         return ((UnwindAssemblyInstEmulation *)baton)->ReadRegister (instruction, reg_info, reg_value);
 537     return false;
 538 }
 539 bool
 540 UnwindAssemblyInstEmulation::ReadRegister (EmulateInstruction *instruction,
 541                                            const RegisterInfo *reg_info,
 542                                            RegisterValue &reg_value)
 543 {
 544     bool synthetic = GetRegisterValue (*reg_info, reg_value);
 545
 546     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 547
 548     if (log && log->GetVerbose ())
 549     {
 550
 551         StreamString strm;
 552         strm.Printf ("UnwindAssemblyInstEmulation::ReadRegister  (name = \"%s\") => synthetic_value = %i, value = ", reg_info->name, synthetic);
 553         reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
 554         log->PutCString(strm.GetData());
 555     }
 556     return true;
 557 }
 558
 559 bool
 560 UnwindAssemblyInstEmulation::WriteRegister (EmulateInstruction *instruction,
 561                                             void *baton,
 562                                             const EmulateInstruction::Context &context,
 563                                             const RegisterInfo *reg_info,
 564                                             const RegisterValue &reg_value)
 565 {
 566     if (baton && reg_info)
 567         return ((UnwindAssemblyInstEmulation *)baton)->WriteRegister (instruction, context, reg_info, reg_value);
 568     return false;
 569 }
 570 bool
 571 UnwindAssemblyInstEmulation::WriteRegister (EmulateInstruction *instruction,
 572                                             const EmulateInstruction::Context &context,
 573                                             const RegisterInfo *reg_info,
 574                                             const RegisterValue &reg_value)
 575 {
 576     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_UNWIND));
 577
 578     if (log && log->GetVerbose ())
 579     {
 580
 581         StreamString strm;
 582         strm.Printf ("UnwindAssemblyInstEmulation::WriteRegister (name = \"%s\", value = ", reg_info->name);
 583         reg_value.Dump(&strm, reg_info, false, false, eFormatDefault);
 584         strm.PutCString (", context = ");
 585         context.Dump(strm, instruction);
 586         log->PutCString(strm.GetData());
 587     }
 588
 589     const bool must_replace = true;
 590     SetRegisterValue (*reg_info, reg_value);
 591
 592     switch (context.type)
 593     {
 594         case EmulateInstruction::eContextInvalid:
 595         case EmulateInstruction::eContextReadOpcode:
 596         case EmulateInstruction::eContextImmediate:
 597         case EmulateInstruction::eContextAdjustBaseRegister:
 598         case EmulateInstruction::eContextRegisterPlusOffset:
 599         case EmulateInstruction::eContextAdjustPC:
 600         case EmulateInstruction::eContextRegisterStore:
 601         case EmulateInstruction::eContextRegisterLoad:
 602         case EmulateInstruction::eContextAbsoluteBranchRegister:
 603         case EmulateInstruction::eContextSupervisorCall:
 604         case EmulateInstruction::eContextTableBranchReadMemory:
 605         case EmulateInstruction::eContextWriteRegisterRandomBits:
 606         case EmulateInstruction::eContextWriteMemoryRandomBits:
 607         case EmulateInstruction::eContextArithmetic:
 608         case EmulateInstruction::eContextAdvancePC:
 609         case EmulateInstruction::eContextReturnFromException:
 610         case EmulateInstruction::eContextPushRegisterOnStack:
 611 //            {
 612 //                const uint32_t reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
 613 //                if (reg_num != LLDB_INVALID_REGNUM)
 614 //                {
 615 //                    const bool can_replace_only_if_unspecified = true;
 616 //
 617 //                    m_curr_row.SetRegisterLocationToUndefined (reg_num,
 618 //                                                               can_replace_only_if_unspecified,
 619 //                                                               can_replace_only_if_unspecified);
 620 //                    m_curr_row_modified = true;
 621 //                }
 622 //            }
 623             break;
 624
 625         case EmulateInstruction::eContextRelativeBranchImmediate:
 626             {
 627
 628                 {
 629                     m_curr_insn_is_branch_immediate = true;
 630                 }
 631             }
 632             break;
 633
 634         case EmulateInstruction::eContextPopRegisterOffStack:
 635             {
 636                 const uint32_t reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
 637                 if (reg_num != LLDB_INVALID_REGNUM)
 638                 {
 639                     m_curr_row->SetRegisterLocationToSame (reg_num, must_replace);
 640                     m_curr_row_modified = true;
 641                     m_curr_insn_restored_a_register = true;
 642                 }
 643             }
 644             break;
 645
 646         case EmulateInstruction::eContextSetFramePointer:
 647             if (!m_fp_is_cfa)
 648             {
 649                 m_fp_is_cfa = true;
 650                 m_cfa_reg_info = *reg_info;
 651                 const uint32_t cfa_reg_num = reg_info->kinds[m_unwind_plan_ptr->GetRegisterKind()];
 652                 assert (cfa_reg_num != LLDB_INVALID_REGNUM);
 653                 m_curr_row->SetCFARegister(cfa_reg_num);
 654                 m_curr_row->SetCFAOffset(m_initial_sp - reg_value.GetAsUInt64());
 655                 m_curr_row_modified = true;
 656             }
 657             break;
 658
 659         case EmulateInstruction::eContextAdjustStackPointer:
 660             // If we have created a frame using the frame pointer, don't follow
 661             // subsequent adjustments to the stack pointer.
 662             if (!m_fp_is_cfa)
 663             {
 664                 m_curr_row->SetCFAOffset (m_initial_sp - reg_value.GetAsUInt64());
 665                 m_curr_row_modified = true;
 666             }
 667             break;
 668     }
 669     return true;
 670 }
 671
 672