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