contrib/llvm/tools/lldb/source/Target/ThreadPlanTracer.cpp

   1 //===-- ThreadPlan.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 "lldb/lldb-python.h"
  11
  12 #include "lldb/Target/ThreadPlan.h"
  13
  14 // C Includes
  15 #include <string.h>
  16 // C++ Includes
  17 // Other libraries and framework includes
  18 // Project includes
  19 #include "lldb/Core/ArchSpec.h"
  20 #include "lldb/Core/DataBufferHeap.h"
  21 #include "lldb/Core/Debugger.h"
  22 #include "lldb/Core/Disassembler.h"
  23 #include "lldb/Core/Log.h"
  24 #include "lldb/Core/Module.h"
  25 #include "lldb/Core/State.h"
  26 #include "lldb/Core/StreamFile.h"
  27 #include "lldb/Core/Value.h"
  28 #include "lldb/Symbol/TypeList.h"
  29 #include "lldb/Target/RegisterContext.h"
  30 #include "lldb/Target/Thread.h"
  31 #include "lldb/Target/Process.h"
  32 #include "lldb/Target/SectionLoadList.h"
  33 #include "lldb/Target/Target.h"
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37
  38 #pragma mark ThreadPlanTracer
  39
  40 ThreadPlanTracer::ThreadPlanTracer (Thread &thread, lldb::StreamSP &stream_sp) :
  41     m_thread (thread),
  42     m_single_step(true),
  43     m_enabled (false),
  44     m_stream_sp (stream_sp)
  45 {
  46 }
  47
  48 ThreadPlanTracer::ThreadPlanTracer (Thread &thread) :
  49     m_thread (thread),
  50     m_single_step(true),
  51     m_enabled (false),
  52     m_stream_sp ()
  53 {
  54 }
  55
  56 Stream *
  57 ThreadPlanTracer::GetLogStream ()
  58 {
  59
  60     if (m_stream_sp.get())
  61         return m_stream_sp.get();
  62     else
  63     {
  64         TargetSP target_sp (m_thread.CalculateTarget());
  65         if (target_sp)
  66             return target_sp->GetDebugger().GetOutputFile().get();
  67     }
  68     return NULL;
  69 }
  70
  71 void
  72 ThreadPlanTracer::Log()
  73 {
  74     SymbolContext sc;
  75     bool show_frame_index = false;
  76     bool show_fullpaths = false;
  77
  78     Stream *stream = GetLogStream();
  79     if (stream)
  80     {
  81         m_thread.GetStackFrameAtIndex(0)->Dump (stream, show_frame_index, show_fullpaths);
  82         stream->Printf("\n");
  83         stream->Flush();
  84     }
  85
  86 }
  87
  88 bool
  89 ThreadPlanTracer::TracerExplainsStop ()
  90 {
  91     if (m_enabled && m_single_step)
  92     {
  93         lldb::StopInfoSP stop_info = m_thread.GetStopInfo();
  94         if (stop_info->GetStopReason() == eStopReasonTrace)
  95             return true;
  96         else
  97             return false;
  98     }
  99     else
 100         return false;
 101 }
 102
 103 #pragma mark ThreadPlanAssemblyTracer
 104
 105 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer (Thread &thread, lldb::StreamSP &stream_sp) :
 106     ThreadPlanTracer (thread, stream_sp),
 107     m_disassembler_sp (),
 108     m_intptr_type (),
 109     m_register_values ()
 110 {
 111 }
 112
 113 ThreadPlanAssemblyTracer::ThreadPlanAssemblyTracer (Thread &thread) :
 114     ThreadPlanTracer (thread),
 115     m_disassembler_sp (),
 116     m_intptr_type (),
 117     m_register_values ()
 118 {
 119 }
 120
 121 Disassembler *
 122 ThreadPlanAssemblyTracer::GetDisassembler ()
 123 {
 124     if (m_disassembler_sp.get() == NULL)
 125         m_disassembler_sp = Disassembler::FindPlugin(m_thread.GetProcess()->GetTarget().GetArchitecture(), NULL, NULL);
 126     return m_disassembler_sp.get();
 127 }
 128
 129 TypeFromUser
 130 ThreadPlanAssemblyTracer::GetIntPointerType()
 131 {
 132     if (!m_intptr_type.IsValid ())
 133     {
 134         TargetSP target_sp (m_thread.CalculateTarget());
 135         if (target_sp)
 136         {
 137             Module *exe_module = target_sp->GetExecutableModulePointer();
 138
 139             if (exe_module)
 140             {
 141                 m_intptr_type = TypeFromUser(exe_module->GetClangASTContext().GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, target_sp->GetArchitecture().GetAddressByteSize() * 8));
 142             }
 143         }
 144     }
 145     return m_intptr_type;
 146 }
 147
 148
 149
 150 ThreadPlanAssemblyTracer::~ThreadPlanAssemblyTracer()
 151 {
 152 }
 153
 154 void
 155 ThreadPlanAssemblyTracer::TracingStarted ()
 156 {
 157     RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
 158
 159     if (m_register_values.size() == 0)
 160         m_register_values.resize (reg_ctx->GetRegisterCount());
 161 }
 162
 163 void
 164 ThreadPlanAssemblyTracer::TracingEnded ()
 165 {
 166     m_register_values.clear();
 167 }
 168
 169 static void
 170 PadOutTo (StreamString &stream, int target)
 171 {
 172     stream.Flush();
 173
 174     int length = stream.GetString().length();
 175
 176     if (length + 1 < target)
 177         stream.Printf("%*s", target - (length + 1) + 1, "");
 178 }
 179
 180 void
 181 ThreadPlanAssemblyTracer::Log ()
 182 {
 183     Stream *stream = GetLogStream ();
 184
 185     if (!stream)
 186         return;
 187
 188     RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
 189
 190     lldb::addr_t pc = reg_ctx->GetPC();
 191     ProcessSP process_sp (m_thread.GetProcess());
 192     Address pc_addr;
 193     bool addr_valid = false;
 194     uint8_t buffer[16] = {0}; // Must be big enough for any single instruction
 195     addr_valid = process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress (pc, pc_addr);
 196
 197     pc_addr.Dump(stream, &m_thread, Address::DumpStyleResolvedDescription, Address::DumpStyleModuleWithFileAddress);
 198     stream->PutCString (" ");
 199
 200     Disassembler *disassembler = GetDisassembler();
 201     if (disassembler)
 202     {
 203         Error err;
 204         process_sp->ReadMemory(pc, buffer, sizeof(buffer), err);
 205
 206         if (err.Success())
 207         {
 208             DataExtractor extractor(buffer, sizeof(buffer),
 209                                     process_sp->GetByteOrder(),
 210                                     process_sp->GetAddressByteSize());
 211
 212                         bool data_from_file = false;
 213             if (addr_valid)
 214                 disassembler->DecodeInstructions (pc_addr, extractor, 0, 1, false, data_from_file);
 215             else
 216                 disassembler->DecodeInstructions (Address (pc), extractor, 0, 1, false, data_from_file);
 217
 218             InstructionList &instruction_list = disassembler->GetInstructionList();
 219             const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();
 220
 221             if (instruction_list.GetSize())
 222             {
 223                 const bool show_bytes = true;
 224                 const bool show_address = true;
 225                 Instruction *instruction = instruction_list.GetInstructionAtIndex(0).get();
 226                 instruction->Dump (stream,
 227                                    max_opcode_byte_size,
 228                                    show_address,
 229                                    show_bytes,
 230                                    NULL);
 231             }
 232         }
 233     }
 234
 235     const ABI *abi = process_sp->GetABI().get();
 236     TypeFromUser intptr_type = GetIntPointerType();
 237
 238     if (abi && intptr_type.IsValid())
 239     {
 240         ValueList value_list;
 241         const int num_args = 1;
 242
 243         for (int arg_index = 0; arg_index < num_args; ++arg_index)
 244         {
 245             Value value;
 246             value.SetValueType (Value::eValueTypeScalar);
 247 //            value.SetContext (Value::eContextTypeClangType, intptr_type.GetOpaqueQualType());
 248             value.SetClangType (intptr_type);
 249             value_list.PushValue (value);
 250         }
 251
 252         if (abi->GetArgumentValues (m_thread, value_list))
 253         {
 254             for (int arg_index = 0; arg_index < num_args; ++arg_index)
 255             {
 256                 stream->Printf("\n\targ[%d]=%llx", arg_index, value_list.GetValueAtIndex(arg_index)->GetScalar().ULongLong());
 257
 258                 if (arg_index + 1 < num_args)
 259                     stream->PutCString (", ");
 260             }
 261         }
 262     }
 263
 264
 265     RegisterValue reg_value;
 266     for (uint32_t reg_num = 0, num_registers = reg_ctx->GetRegisterCount();
 267          reg_num < num_registers;
 268          ++reg_num)
 269     {
 270         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
 271         if (reg_ctx->ReadRegister (reg_info, reg_value))
 272         {
 273             assert (reg_num < m_register_values.size());
 274             if (m_register_values[reg_num].GetType() == RegisterValue::eTypeInvalid ||
 275                 reg_value != m_register_values[reg_num])
 276             {
 277                 if (reg_value.GetType() != RegisterValue::eTypeInvalid)
 278                 {
 279                     stream->PutCString ("\n\t");
 280                     reg_value.Dump(stream, reg_info, true, false, eFormatDefault);
 281                 }
 282             }
 283             m_register_values[reg_num] = reg_value;
 284         }
 285     }
 286     stream->EOL();
 287     stream->Flush();
 288 }