contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

   1 //===-- InferiorCallPOSIX.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 "InferiorCallPOSIX.h"
  11 #include "lldb/Core/Address.h"
  12 #include "lldb/Core/StreamFile.h"
  13 #include "lldb/Core/ValueObject.h"
  14 #include "lldb/Symbol/ClangASTContext.h"
  15 #include "lldb/Symbol/SymbolContext.h"
  16 #include "lldb/Target/ExecutionContext.h"
  17 #include "lldb/Target/Process.h"
  18 #include "lldb/Target/Target.h"
  19 #include "lldb/Target/ThreadPlanCallFunction.h"
  20
  21 #include <sys/mman.h>
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 bool lldb_private::InferiorCallMmap(Process *process, addr_t &allocated_addr,
  27                                     addr_t addr, addr_t length, unsigned prot,
  28                                     unsigned flags, addr_t fd, addr_t offset) {
  29     Thread *thread = process->GetThreadList().GetSelectedThread().get();
  30     if (thread == NULL)
  31         return false;
  32
  33     const bool append = true;
  34     const bool include_symbols = true;
  35     const bool include_inlines = false;
  36     SymbolContextList sc_list;
  37     const uint32_t count
  38       = process->GetTarget().GetImages().FindFunctions (ConstString ("mmap"),
  39                                                         eFunctionNameTypeFull,
  40                                                         include_symbols,
  41                                                         include_inlines,
  42                                                         append,
  43                                                         sc_list);
  44     if (count > 0)
  45     {
  46         SymbolContext sc;
  47         if (sc_list.GetContextAtIndex(0, sc))
  48         {
  49             const uint32_t range_scope = eSymbolContextFunction | eSymbolContextSymbol;
  50             const bool use_inline_block_range = false;
  51             const bool stop_other_threads = true;
  52             const bool unwind_on_error = true;
  53             const bool ignore_breakpoints = true;
  54             const bool try_all_threads = true;
  55             const uint32_t timeout_usec = 500000;
  56
  57             addr_t prot_arg, flags_arg = 0;
  58             if (prot == eMmapProtNone)
  59               prot_arg = PROT_NONE;
  60             else {
  61               prot_arg = 0;
  62               if (prot & eMmapProtExec)
  63                 prot_arg |= PROT_EXEC;
  64               if (prot & eMmapProtRead)
  65                 prot_arg |= PROT_READ;
  66               if (prot & eMmapProtWrite)
  67                 prot_arg |= PROT_WRITE;
  68             }
  69
  70             if (flags & eMmapFlagsPrivate)
  71               flags_arg |= MAP_PRIVATE;
  72             if (flags & eMmapFlagsAnon)
  73               flags_arg |= MAP_ANON;
  74
  75             AddressRange mmap_range;
  76             if (sc.GetAddressRange(range_scope, 0, use_inline_block_range, mmap_range))
  77             {
  78                 ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
  79                 ClangASTType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
  80                 ThreadPlanCallFunction *call_function_thread_plan
  81                   = new ThreadPlanCallFunction (*thread,
  82                                                 mmap_range.GetBaseAddress(),
  83                                                 clang_void_ptr_type,
  84                                                 stop_other_threads,
  85                                                 unwind_on_error,
  86                                                 ignore_breakpoints,
  87                                                 &addr,
  88                                                 &length,
  89                                                 &prot_arg,
  90                                                 &flags_arg,
  91                                                 &fd,
  92                                                 &offset);
  93                 lldb::ThreadPlanSP call_plan_sp (call_function_thread_plan);
  94                 if (call_plan_sp)
  95                 {
  96                     StreamFile error_strm;
  97                     // This plan is a utility plan, so set it to discard itself when done.
  98                     call_plan_sp->SetIsMasterPlan (true);
  99                     call_plan_sp->SetOkayToDiscard(true);
 100
 101                     StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
 102                     if (frame)
 103                     {
 104                         ExecutionContext exe_ctx;
 105                         frame->CalculateExecutionContext (exe_ctx);
 106                         ExecutionResults result = process->RunThreadPlan (exe_ctx,
 107                                                                           call_plan_sp,
 108                                                                           stop_other_threads,
 109                                                                           try_all_threads,
 110                                                                           unwind_on_error,
 111                                                                           ignore_breakpoints,
 112                                                                           timeout_usec,
 113                                                                           error_strm);
 114                         if (result == eExecutionCompleted)
 115                         {
 116
 117                             allocated_addr = call_plan_sp->GetReturnValueObject()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 118                             if (process->GetAddressByteSize() == 4)
 119                             {
 120                                 if (allocated_addr == UINT32_MAX)
 121                                     return false;
 122                             }
 123                             else if (process->GetAddressByteSize() == 8)
 124                             {
 125                                 if (allocated_addr == UINT64_MAX)
 126                                     return false;
 127                             }
 128                             return true;
 129                         }
 130                     }
 131                 }
 132             }
 133         }
 134     }
 135
 136     return false;
 137 }
 138
 139 bool lldb_private::InferiorCallMunmap(Process *process, addr_t addr,
 140                                       addr_t length) {
 141    Thread *thread = process->GetThreadList().GetSelectedThread().get();
 142    if (thread == NULL)
 143        return false;
 144
 145    const bool append = true;
 146    const bool include_symbols = true;
 147    const bool include_inlines = false;
 148    SymbolContextList sc_list;
 149    const uint32_t count
 150      = process->GetTarget().GetImages().FindFunctions (ConstString ("munmap"),
 151                                                        eFunctionNameTypeFull,
 152                                                        include_symbols,
 153                                                        include_inlines,
 154                                                        append,
 155                                                        sc_list);
 156    if (count > 0)
 157    {
 158        SymbolContext sc;
 159        if (sc_list.GetContextAtIndex(0, sc))
 160        {
 161            const uint32_t range_scope = eSymbolContextFunction | eSymbolContextSymbol;
 162            const bool use_inline_block_range = false;
 163            const bool stop_other_threads = true;
 164            const bool unwind_on_error = true;
 165            const bool ignore_breakpoints = true;
 166            const bool try_all_threads = true;
 167            const uint32_t timeout_usec = 500000;
 168
 169            AddressRange munmap_range;
 170            if (sc.GetAddressRange(range_scope, 0, use_inline_block_range, munmap_range))
 171            {
 172                lldb::ThreadPlanSP call_plan_sp (new ThreadPlanCallFunction (*thread,
 173                                                                             munmap_range.GetBaseAddress(),
 174                                                                             ClangASTType(),
 175                                                                             stop_other_threads,
 176                                                                             unwind_on_error,
 177                                                                             ignore_breakpoints,
 178                                                                             &addr,
 179                                                                             &length));
 180                if (call_plan_sp)
 181                {
 182                    StreamFile error_strm;
 183                    // This plan is a utility plan, so set it to discard itself when done.
 184                    call_plan_sp->SetIsMasterPlan (true);
 185                    call_plan_sp->SetOkayToDiscard(true);
 186
 187                    StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
 188                    if (frame)
 189                    {
 190                        ExecutionContext exe_ctx;
 191                        frame->CalculateExecutionContext (exe_ctx);
 192                        ExecutionResults result = process->RunThreadPlan (exe_ctx,
 193                                                                          call_plan_sp,
 194                                                                          stop_other_threads,
 195                                                                          try_all_threads,
 196                                                                          unwind_on_error,
 197                                                                          ignore_breakpoints,
 198                                                                          timeout_usec,
 199                                                                          error_strm);
 200                        if (result == eExecutionCompleted)
 201                        {
 202                            return true;
 203                        }
 204                    }
 205                }
 206            }
 207        }
 208    }
 209
 210    return false;
 211 }
 212
 213 bool lldb_private::InferiorCall(Process *process, const Address *address, addr_t &returned_func) {
 214     Thread *thread = process->GetThreadList().GetSelectedThread().get();
 215     if (thread == NULL || address == NULL)
 216         return false;
 217
 218     const bool stop_other_threads = true;
 219     const bool unwind_on_error = true;
 220     const bool ignore_breakpoints = true;
 221     const bool try_all_threads = true;
 222     const uint32_t timeout_usec = 500000;
 223
 224     ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
 225     ClangASTType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
 226     ThreadPlanCallFunction *call_function_thread_plan
 227         = new ThreadPlanCallFunction (*thread,
 228                                       *address,
 229                                       clang_void_ptr_type,
 230                                       stop_other_threads,
 231                                       unwind_on_error,
 232                                       ignore_breakpoints);
 233     lldb::ThreadPlanSP call_plan_sp (call_function_thread_plan);
 234     if (call_plan_sp)
 235     {
 236         StreamFile error_strm;
 237         // This plan is a utility plan, so set it to discard itself when done.
 238         call_plan_sp->SetIsMasterPlan (true);
 239         call_plan_sp->SetOkayToDiscard(true);
 240
 241         StackFrame *frame = thread->GetStackFrameAtIndex (0).get();
 242         if (frame)
 243         {
 244             ExecutionContext exe_ctx;
 245             frame->CalculateExecutionContext (exe_ctx);
 246             ExecutionResults result = process->RunThreadPlan (exe_ctx,
 247                                                               call_plan_sp,
 248                                                               stop_other_threads,
 249                                                               try_all_threads,
 250                                                               unwind_on_error,
 251                                                               ignore_breakpoints,
 252                                                               timeout_usec,
 253                                                               error_strm);
 254             if (result == eExecutionCompleted)
 255             {
 256                 returned_func = call_plan_sp->GetReturnValueObject()->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 257
 258                 if (process->GetAddressByteSize() == 4)
 259                 {
 260                     if (returned_func == UINT32_MAX)
 261                         return false;
 262                 }
 263                 else if (process->GetAddressByteSize() == 8)
 264                 {
 265                     if (returned_func == UINT64_MAX)
 266                         return false;
 267                 }
 268                 return true;
 269             }
 270         }
 271     }
 272
 273     return false;
 274 }