blob: 06f25fb24eacffc5d297f85a5a4609bfca8877cb [file] [log] [blame]
Sean Callanan65dafa82010-08-27 01:01:44 +00001//===-- ClangExpressionParser.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/Expression/ClangExpressionParser.h"
11
12#include "lldb/Core/ArchSpec.h"
13#include "lldb/Core/DataBufferHeap.h"
Sean Callanan97c924e2011-01-27 01:07:04 +000014#include "lldb/Core/Debugger.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000015#include "lldb/Core/Disassembler.h"
16#include "lldb/Core/Stream.h"
Sean Callananf18d91c2010-09-01 00:58:00 +000017#include "lldb/Core/StreamString.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000018#include "lldb/Expression/ClangASTSource.h"
19#include "lldb/Expression/ClangExpression.h"
Sean Callananfb3058e2011-05-12 23:54:16 +000020#include "lldb/Expression/ClangExpressionDeclMap.h"
Sean Callananf18d91c2010-09-01 00:58:00 +000021#include "lldb/Expression/IRDynamicChecks.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000022#include "lldb/Expression/RecordingMemoryManager.h"
23#include "lldb/Target/ExecutionContext.h"
Sean Callananc7674af2011-01-17 23:42:46 +000024#include "lldb/Target/ObjCLanguageRuntime.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000025#include "lldb/Target/Process.h"
26#include "lldb/Target/Target.h"
27
28#include "clang/AST/ASTContext.h"
29#include "clang/AST/ExternalASTSource.h"
30#include "clang/Basic/FileManager.h"
31#include "clang/Basic/TargetInfo.h"
32#include "clang/Basic/Version.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000033#include "clang/CodeGen/CodeGenAction.h"
34#include "clang/CodeGen/ModuleBuilder.h"
35#include "clang/Driver/CC1Options.h"
36#include "clang/Driver/OptTable.h"
37#include "clang/Frontend/CompilerInstance.h"
38#include "clang/Frontend/CompilerInvocation.h"
39#include "clang/Frontend/FrontendActions.h"
40#include "clang/Frontend/FrontendDiagnostic.h"
41#include "clang/Frontend/FrontendPluginRegistry.h"
42#include "clang/Frontend/TextDiagnosticBuffer.h"
43#include "clang/Frontend/TextDiagnosticPrinter.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000044#include "clang/Lex/Preprocessor.h"
Sean Callanan47a5c4c2010-09-23 03:01:22 +000045#include "clang/Parse/ParseAST.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000046#include "clang/Rewrite/FrontendActions.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000047#include "clang/Sema/SemaConsumer.h"
Sean Callanan279584c2011-03-15 00:17:19 +000048#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000049
50#include "llvm/ADT/StringRef.h"
51#include "llvm/ExecutionEngine/ExecutionEngine.h"
Sean Callananc1535182011-10-07 23:18:13 +000052#include "llvm/Support/TargetSelect.h"
Greg Clayton2f085c62011-05-15 01:25:55 +000053
Peter Collingbournec3f55732011-06-03 20:40:12 +000054#if !defined(__APPLE__)
55#define USE_STANDARD_JIT
56#endif
57
Greg Clayton2f085c62011-05-15 01:25:55 +000058#if defined (USE_STANDARD_JIT)
Sean Callanan65dafa82010-08-27 01:01:44 +000059#include "llvm/ExecutionEngine/JIT.h"
Greg Clayton2f085c62011-05-15 01:25:55 +000060#else
61#include "llvm/ExecutionEngine/MCJIT.h"
62#endif
Sean Callanan65dafa82010-08-27 01:01:44 +000063#include "llvm/LLVMContext.h"
Sean Callanan279584c2011-03-15 00:17:19 +000064#include "llvm/Module.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000065#include "llvm/Support/ErrorHandling.h"
66#include "llvm/Support/MemoryBuffer.h"
Greg Clayton22defe82010-12-02 23:20:03 +000067#include "llvm/Support/DynamicLibrary.h"
68#include "llvm/Support/Host.h"
69#include "llvm/Support/Signals.h"
Sean Callanan65dafa82010-08-27 01:01:44 +000070
71using namespace clang;
72using namespace llvm;
73using namespace lldb_private;
74
75//===----------------------------------------------------------------------===//
76// Utility Methods for Clang
77//===----------------------------------------------------------------------===//
78
79std::string GetBuiltinIncludePath(const char *Argv0) {
80 llvm::sys::Path P =
81 llvm::sys::Path::GetMainExecutable(Argv0,
82 (void*)(intptr_t) GetBuiltinIncludePath);
83
84 if (!P.isEmpty()) {
85 P.eraseComponent(); // Remove /clang from foo/bin/clang
86 P.eraseComponent(); // Remove /bin from foo/bin
87
88 // Get foo/lib/clang/<version>/include
89 P.appendComponent("lib");
90 P.appendComponent("clang");
91 P.appendComponent(CLANG_VERSION_STRING);
92 P.appendComponent("include");
93 }
94
95 return P.str();
96}
97
98
99//===----------------------------------------------------------------------===//
100// Main driver for Clang
101//===----------------------------------------------------------------------===//
102
103static void LLVMErrorHandler(void *UserData, const std::string &Message) {
Sean Callananc1535182011-10-07 23:18:13 +0000104 DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
Sean Callanan65dafa82010-08-27 01:01:44 +0000105
106 Diags.Report(diag::err_fe_error_backend) << Message;
107
108 // We cannot recover from llvm errors.
Sean Callananc1535182011-10-07 23:18:13 +0000109 assert(0);
Sean Callanan65dafa82010-08-27 01:01:44 +0000110}
111
112static FrontendAction *CreateFrontendBaseAction(CompilerInstance &CI) {
113 using namespace clang::frontend;
114
115 switch (CI.getFrontendOpts().ProgramAction) {
116 default:
117 llvm_unreachable("Invalid program action!");
118
119 case ASTDump: return new ASTDumpAction();
120 case ASTPrint: return new ASTPrintAction();
Sean Callanan279584c2011-03-15 00:17:19 +0000121 case ASTDumpXML: return new ASTDumpXMLAction();
Sean Callanan65dafa82010-08-27 01:01:44 +0000122 case ASTView: return new ASTViewAction();
Sean Callanan65dafa82010-08-27 01:01:44 +0000123 case DumpRawTokens: return new DumpRawTokensAction();
124 case DumpTokens: return new DumpTokensAction();
125 case EmitAssembly: return new EmitAssemblyAction();
126 case EmitBC: return new EmitBCAction();
127 case EmitHTML: return new HTMLPrintAction();
128 case EmitLLVM: return new EmitLLVMAction();
129 case EmitLLVMOnly: return new EmitLLVMOnlyAction();
130 case EmitCodeGenOnly: return new EmitCodeGenOnlyAction();
131 case EmitObj: return new EmitObjAction();
132 case FixIt: return new FixItAction();
Sean Callanan05230832011-12-01 04:31:46 +0000133 case GeneratePCH: return new GeneratePCHAction();
Sean Callanan65dafa82010-08-27 01:01:44 +0000134 case GeneratePTH: return new GeneratePTHAction();
Sean Callanan65dafa82010-08-27 01:01:44 +0000135 case InitOnly: return new InitOnlyAction();
136 case ParseSyntaxOnly: return new SyntaxOnlyAction();
137
138 case PluginAction: {
139 for (FrontendPluginRegistry::iterator it =
140 FrontendPluginRegistry::begin(), ie = FrontendPluginRegistry::end();
141 it != ie; ++it) {
142 if (it->getName() == CI.getFrontendOpts().ActionName) {
143 llvm::OwningPtr<PluginASTAction> P(it->instantiate());
144 if (!P->ParseArgs(CI, CI.getFrontendOpts().PluginArgs))
145 return 0;
146 return P.take();
147 }
148 }
149
150 CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name)
151 << CI.getFrontendOpts().ActionName;
152 return 0;
153 }
154
155 case PrintDeclContext: return new DeclContextPrintAction();
156 case PrintPreamble: return new PrintPreambleAction();
157 case PrintPreprocessedInput: return new PrintPreprocessedAction();
158 case RewriteMacros: return new RewriteMacrosAction();
159 case RewriteObjC: return new RewriteObjCAction();
160 case RewriteTest: return new RewriteTestAction();
Sean Callananad293092011-01-18 23:32:05 +0000161 //case RunAnalysis: return new AnalysisAction();
Sean Callanan65dafa82010-08-27 01:01:44 +0000162 case RunPreprocessorOnly: return new PreprocessOnlyAction();
163 }
164}
165
166static FrontendAction *CreateFrontendAction(CompilerInstance &CI) {
167 // Create the underlying action.
168 FrontendAction *Act = CreateFrontendBaseAction(CI);
169 if (!Act)
170 return 0;
171
172 // If there are any AST files to merge, create a frontend action
173 // adaptor to perform the merge.
174 if (!CI.getFrontendOpts().ASTMergeFiles.empty())
Sean Callanan8f2e3922012-02-04 08:49:35 +0000175 Act = new ASTMergeAction(Act, CI.getFrontendOpts().ASTMergeFiles);
Sean Callanan65dafa82010-08-27 01:01:44 +0000176
177 return Act;
178}
179
180//===----------------------------------------------------------------------===//
181// Implementation of ClangExpressionParser
182//===----------------------------------------------------------------------===//
183
Greg Clayton395fc332011-02-15 21:59:32 +0000184ClangExpressionParser::ClangExpressionParser (ExecutionContextScope *exe_scope,
185 ClangExpression &expr) :
186 m_expr (expr),
Sean Callanan65dafa82010-08-27 01:01:44 +0000187 m_compiler (),
188 m_code_generator (NULL),
Sean Callanan65dafa82010-08-27 01:01:44 +0000189 m_jitted_functions ()
190{
191 // Initialize targets first, so that --version shows registered targets.
192 static struct InitializeLLVM {
193 InitializeLLVM() {
194 llvm::InitializeAllTargets();
195 llvm::InitializeAllAsmPrinters();
Sean Callanan9b6898f2011-07-30 02:42:06 +0000196 llvm::InitializeAllTargetMCs();
Sean Callanan05230832011-12-01 04:31:46 +0000197 llvm::InitializeAllDisassemblers();
Sean Callanan65dafa82010-08-27 01:01:44 +0000198 }
199 } InitializeLLVM;
Greg Clayton395fc332011-02-15 21:59:32 +0000200
Sean Callanan65dafa82010-08-27 01:01:44 +0000201 // 1. Create a new compiler instance.
202 m_compiler.reset(new CompilerInstance());
Sean Callanan65dafa82010-08-27 01:01:44 +0000203
204 // 2. Set options.
205
Sean Callanan5b658cc2011-11-07 23:35:40 +0000206 lldb::LanguageType language = expr.Language();
Greg Claytonf51ed302011-01-15 01:32:14 +0000207
Sean Callanan5b658cc2011-11-07 23:35:40 +0000208 switch (language)
209 {
210 case lldb::eLanguageTypeC:
211 break;
212 case lldb::eLanguageTypeObjC:
213 m_compiler->getLangOpts().ObjC1 = true;
214 m_compiler->getLangOpts().ObjC2 = true;
215 break;
216 case lldb::eLanguageTypeC_plus_plus:
217 m_compiler->getLangOpts().CPlusPlus = true;
218 break;
219 case lldb::eLanguageTypeObjC_plus_plus:
220 default:
221 m_compiler->getLangOpts().ObjC1 = true;
222 m_compiler->getLangOpts().ObjC2 = true;
223 m_compiler->getLangOpts().CPlusPlus = true;
224 break;
225 }
Sean Callananc7674af2011-01-17 23:42:46 +0000226
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000227 m_compiler->getLangOpts().DebuggerSupport = true; // Features specifically for debugger clients
228 if (expr.DesiredResultType() == ClangExpression::eResultTypeId)
229 m_compiler->getLangOpts().DebuggerCastResultToId = true;
230
Sean Callanan6c797dc2012-04-17 00:49:48 +0000231 // Spell checking is a nice feature, but it ends up completing a
232 // lot of types that we didn't strictly speaking need to complete.
233 // As a result, we spend a long time parsing and importing debug
234 // information.
235 m_compiler->getLangOpts().SpellChecking = false;
236
Greg Clayton289afcb2012-02-18 05:35:26 +0000237 lldb::ProcessSP process_sp;
Greg Clayton395fc332011-02-15 21:59:32 +0000238 if (exe_scope)
Greg Clayton289afcb2012-02-18 05:35:26 +0000239 process_sp = exe_scope->CalculateProcess();
Greg Clayton395fc332011-02-15 21:59:32 +0000240
Greg Clayton289afcb2012-02-18 05:35:26 +0000241 if (process_sp && m_compiler->getLangOpts().ObjC1)
Sean Callananc7674af2011-01-17 23:42:46 +0000242 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000243 if (process_sp->GetObjCLanguageRuntime())
Sean Callananc7674af2011-01-17 23:42:46 +0000244 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000245 if (process_sp->GetObjCLanguageRuntime()->GetRuntimeVersion() == eAppleObjC_V2)
Sean Callananc7674af2011-01-17 23:42:46 +0000246 {
247 m_compiler->getLangOpts().ObjCNonFragileABI = true; // NOT i386
248 m_compiler->getLangOpts().ObjCNonFragileABI2 = true; // NOT i386
249 }
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000250
251 if (process_sp->GetObjCLanguageRuntime()->HasNewLiteralsAndIndexing())
252 {
253 m_compiler->getLangOpts().DebuggerObjCLiteral = true;
254 }
Sean Callananc7674af2011-01-17 23:42:46 +0000255 }
256 }
Greg Claytonf51ed302011-01-15 01:32:14 +0000257
Sean Callanan65dafa82010-08-27 01:01:44 +0000258 m_compiler->getLangOpts().ThreadsafeStatics = false;
259 m_compiler->getLangOpts().AccessControl = false; // Debuggers get universal access
260 m_compiler->getLangOpts().DollarIdents = true; // $ indicates a persistent variable name
Sean Callanandaa6efe2011-12-21 22:22:58 +0000261
Sean Callanan65dafa82010-08-27 01:01:44 +0000262 // Set CodeGen options
263 m_compiler->getCodeGenOpts().EmitDeclMetadata = true;
264 m_compiler->getCodeGenOpts().InstrumentFunctions = false;
265
266 // Disable some warnings.
267 m_compiler->getDiagnosticOpts().Warnings.push_back("no-unused-value");
268
269 // Set the target triple.
Greg Clayton289afcb2012-02-18 05:35:26 +0000270 lldb::TargetSP target_sp;
Greg Clayton395fc332011-02-15 21:59:32 +0000271 if (exe_scope)
Greg Clayton289afcb2012-02-18 05:35:26 +0000272 target_sp = exe_scope->CalculateTarget();
Greg Clayton395fc332011-02-15 21:59:32 +0000273
274 // TODO: figure out what to really do when we don't have a valid target.
275 // Sometimes this will be ok to just use the host target triple (when we
276 // evaluate say "2+3", but other expressions like breakpoint conditions
277 // and other things that _are_ target specific really shouldn't just be
278 // using the host triple. This needs to be fixed in a better way.
Greg Clayton289afcb2012-02-18 05:35:26 +0000279 if (target_sp && target_sp->GetArchitecture().IsValid())
Sean Callanan2a8c3382011-04-14 02:01:31 +0000280 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000281 std::string triple = target_sp->GetArchitecture().GetTriple().str();
Sean Callanan2a8c3382011-04-14 02:01:31 +0000282
283 int dash_count = 0;
Johnny Chen2bc9eb32011-07-19 19:48:13 +0000284 for (size_t i = 0; i < triple.size(); ++i)
Sean Callanan2a8c3382011-04-14 02:01:31 +0000285 {
286 if (triple[i] == '-')
287 dash_count++;
288 if (dash_count == 3)
289 {
290 triple.resize(i);
291 break;
292 }
293 }
294
295 m_compiler->getTargetOpts().Triple = triple;
296 }
Greg Clayton395fc332011-02-15 21:59:32 +0000297 else
Sean Callanan2a8c3382011-04-14 02:01:31 +0000298 {
Sean Callanan7537dce2011-11-04 22:46:46 +0000299 m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
Sean Callanan2a8c3382011-04-14 02:01:31 +0000300 }
301
Sean Callanan65dafa82010-08-27 01:01:44 +0000302 // 3. Set up various important bits of infrastructure.
303 m_compiler->createDiagnostics(0, 0);
304
305 // Create the target instance.
306 m_compiler->setTarget(TargetInfo::CreateTargetInfo(m_compiler->getDiagnostics(),
307 m_compiler->getTargetOpts()));
308
309 assert (m_compiler->hasTarget());
310
311 // Inform the target of the language options
312 //
313 // FIXME: We shouldn't need to do this, the target should be immutable once
314 // created. This complexity should be lifted elsewhere.
315 m_compiler->getTarget().setForcedLangOptions(m_compiler->getLangOpts());
316
317 // 4. Set up the diagnostic buffer for reporting errors
318
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000319 m_compiler->getDiagnostics().setClient(new clang::TextDiagnosticBuffer);
Sean Callanan65dafa82010-08-27 01:01:44 +0000320
321 // 5. Set up the source management objects inside the compiler
322
Greg Clayton22defe82010-12-02 23:20:03 +0000323 clang::FileSystemOptions file_system_options;
324 m_file_manager.reset(new clang::FileManager(file_system_options));
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000325
Sean Callanan65dafa82010-08-27 01:01:44 +0000326 if (!m_compiler->hasSourceManager())
Greg Clayton22defe82010-12-02 23:20:03 +0000327 m_compiler->createSourceManager(*m_file_manager.get());
Sean Callanan65dafa82010-08-27 01:01:44 +0000328
329 m_compiler->createFileManager();
330 m_compiler->createPreprocessor();
331
332 // 6. Most of this we get from the CompilerInstance, but we
333 // also want to give the context an ExternalASTSource.
Sean Callananee8fc722010-11-19 20:20:02 +0000334 m_selector_table.reset(new SelectorTable());
Sean Callananc1535182011-10-07 23:18:13 +0000335 m_builtin_context.reset(new Builtin::Context());
Sean Callanan65dafa82010-08-27 01:01:44 +0000336
337 std::auto_ptr<clang::ASTContext> ast_context(new ASTContext(m_compiler->getLangOpts(),
338 m_compiler->getSourceManager(),
Sean Callananc1535182011-10-07 23:18:13 +0000339 &m_compiler->getTarget(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000340 m_compiler->getPreprocessor().getIdentifierTable(),
Sean Callananee8fc722010-11-19 20:20:02 +0000341 *m_selector_table.get(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000342 *m_builtin_context.get(),
343 0));
344
345 ClangExpressionDeclMap *decl_map = m_expr.DeclMap();
346
347 if (decl_map)
348 {
Sean Callananf76afff2011-10-28 23:38:38 +0000349 llvm::OwningPtr<clang::ExternalASTSource> ast_source(decl_map->CreateProxy());
350 decl_map->InstallASTContext(ast_context.get());
Sean Callanan65dafa82010-08-27 01:01:44 +0000351 ast_context->setExternalSource(ast_source);
352 }
353
354 m_compiler->setASTContext(ast_context.release());
355
Greg Clayton8de27c72010-10-15 22:48:33 +0000356 std::string module_name("$__lldb_module");
Sean Callanan65dafa82010-08-27 01:01:44 +0000357
Sean Callanan279584c2011-03-15 00:17:19 +0000358 m_llvm_context.reset(new LLVMContext());
Sean Callanan65dafa82010-08-27 01:01:44 +0000359 m_code_generator.reset(CreateLLVMCodeGen(m_compiler->getDiagnostics(),
360 module_name,
361 m_compiler->getCodeGenOpts(),
Sean Callanan279584c2011-03-15 00:17:19 +0000362 *m_llvm_context));
Sean Callanan65dafa82010-08-27 01:01:44 +0000363}
364
365ClangExpressionParser::~ClangExpressionParser()
366{
367}
368
369unsigned
370ClangExpressionParser::Parse (Stream &stream)
371{
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000372 TextDiagnosticBuffer *diag_buf = static_cast<TextDiagnosticBuffer*>(m_compiler->getDiagnostics().getClient());
373
374 diag_buf->FlushDiagnostics (m_compiler->getDiagnostics());
Sean Callanan65dafa82010-08-27 01:01:44 +0000375
376 MemoryBuffer *memory_buffer = MemoryBuffer::getMemBufferCopy(m_expr.Text(), __FUNCTION__);
Sean Callanan142f94c2012-03-01 02:03:47 +0000377 m_compiler->getSourceManager().createMainFileIDForMemBuffer (memory_buffer);
Sean Callanan65dafa82010-08-27 01:01:44 +0000378
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000379 diag_buf->BeginSourceFile(m_compiler->getLangOpts(), &m_compiler->getPreprocessor());
Sean Callanan65dafa82010-08-27 01:01:44 +0000380
381 ASTConsumer *ast_transformer = m_expr.ASTTransformer(m_code_generator.get());
382
383 if (ast_transformer)
384 ParseAST(m_compiler->getPreprocessor(), ast_transformer, m_compiler->getASTContext());
385 else
386 ParseAST(m_compiler->getPreprocessor(), m_code_generator.get(), m_compiler->getASTContext());
387
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000388 diag_buf->EndSourceFile();
Sean Callananfb3058e2011-05-12 23:54:16 +0000389
Sean Callanan65dafa82010-08-27 01:01:44 +0000390 TextDiagnosticBuffer::const_iterator diag_iterator;
391
392 int num_errors = 0;
Sean Callanan7617c292010-11-01 20:28:09 +0000393
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000394 for (diag_iterator = diag_buf->warn_begin();
395 diag_iterator != diag_buf->warn_end();
Sean Callanan65dafa82010-08-27 01:01:44 +0000396 ++diag_iterator)
397 stream.Printf("warning: %s\n", (*diag_iterator).second.c_str());
398
399 num_errors = 0;
400
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000401 for (diag_iterator = diag_buf->err_begin();
402 diag_iterator != diag_buf->err_end();
Sean Callanan65dafa82010-08-27 01:01:44 +0000403 ++diag_iterator)
404 {
405 num_errors++;
406 stream.Printf("error: %s\n", (*diag_iterator).second.c_str());
407 }
408
Sean Callanan7617c292010-11-01 20:28:09 +0000409 for (diag_iterator = diag_buf->note_begin();
410 diag_iterator != diag_buf->note_end();
411 ++diag_iterator)
412 stream.Printf("note: %s\n", (*diag_iterator).second.c_str());
413
Sean Callananfb3058e2011-05-12 23:54:16 +0000414 if (!num_errors)
415 {
416 if (m_expr.DeclMap() && !m_expr.DeclMap()->ResolveUnknownTypes())
417 {
418 stream.Printf("error: Couldn't infer the type of a variable\n");
419 num_errors++;
420 }
421 }
422
Sean Callanan65dafa82010-08-27 01:01:44 +0000423 return num_errors;
424}
425
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000426static bool FindFunctionInModule (std::string &mangled_name,
427 llvm::Module *module,
428 const char *orig_name)
429{
430 for (llvm::Module::iterator fi = module->getFunctionList().begin(), fe = module->getFunctionList().end();
431 fi != fe;
432 ++fi)
433 {
434 if (fi->getName().str().find(orig_name) != std::string::npos)
435 {
436 mangled_name = fi->getName().str();
437 return true;
438 }
439 }
440
441 return false;
442}
443
Sean Callanan65dafa82010-08-27 01:01:44 +0000444Error
Sean Callanan47dc4572011-09-15 02:13:07 +0000445ClangExpressionParser::PrepareForExecution (lldb::addr_t &func_allocation_addr,
446 lldb::addr_t &func_addr,
447 lldb::addr_t &func_end,
448 ExecutionContext &exe_ctx,
449 IRForTarget::StaticDataAllocator *data_allocator,
450 bool &evaluated_statically,
451 lldb::ClangExpressionVariableSP &const_result,
452 ExecutionPolicy execution_policy)
Sean Callanan65dafa82010-08-27 01:01:44 +0000453{
Greg Claytond0882d02011-01-19 23:00:49 +0000454 func_allocation_addr = LLDB_INVALID_ADDRESS;
455 func_addr = LLDB_INVALID_ADDRESS;
456 func_end = LLDB_INVALID_ADDRESS;
Greg Claytone005f2c2010-11-06 01:53:30 +0000457 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000458
Sean Callananddf110d2012-01-24 22:06:48 +0000459 std::auto_ptr<llvm::ExecutionEngine> execution_engine;
460
Sean Callanan65dafa82010-08-27 01:01:44 +0000461 Error err;
462
463 llvm::Module *module = m_code_generator->ReleaseModule();
464
465 if (!module)
466 {
467 err.SetErrorToGenericError();
468 err.SetErrorString("IR doesn't contain a module");
469 return err;
470 }
471
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000472 // Find the actual name of the function (it's often mangled somehow)
473
474 std::string function_name;
475
476 if (!FindFunctionInModule(function_name, module, m_expr.FunctionName()))
477 {
478 err.SetErrorToGenericError();
479 err.SetErrorStringWithFormat("Couldn't find %s() in the module", m_expr.FunctionName());
480 return err;
481 }
482 else
483 {
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000484 if (log)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000485 log->Printf("Found function %s for %s", function_name.c_str(), m_expr.FunctionName());
486 }
487
Sean Callanan65dafa82010-08-27 01:01:44 +0000488 ClangExpressionDeclMap *decl_map = m_expr.DeclMap(); // result can be NULL
489
490 if (decl_map)
491 {
Sean Callanan97c924e2011-01-27 01:07:04 +0000492 Stream *error_stream = NULL;
Greg Clayton567e7f32011-09-22 04:58:26 +0000493 Target *target = exe_ctx.GetTargetPtr();
494 if (target)
495 error_stream = &target->GetDebugger().GetErrorStream();
Sean Callanan97c924e2011-01-27 01:07:04 +0000496
Sean Callanan47dc4572011-09-15 02:13:07 +0000497 IRForTarget ir_for_target(decl_map,
Sean Callanane8a59a82010-09-13 21:34:21 +0000498 m_expr.NeedsVariableResolution(),
Sean Callanan47dc4572011-09-15 02:13:07 +0000499 execution_policy,
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000500 const_result,
Sean Callananc0492742011-05-23 21:40:23 +0000501 data_allocator,
Sean Callanan97c924e2011-01-27 01:07:04 +0000502 error_stream,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000503 function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000504
Sean Callanan8f2e3922012-02-04 08:49:35 +0000505 ir_for_target.runOnModule(*module);
Sean Callananf18d91c2010-09-01 00:58:00 +0000506
Sean Callananddf110d2012-01-24 22:06:48 +0000507 Error &interpreter_error(ir_for_target.getInterpreterError());
508
509 if (execution_policy != eExecutionPolicyAlways && interpreter_error.Success())
Sean Callanan696cf5f2011-05-07 01:06:41 +0000510 {
Johnny Chenc6134962012-01-06 00:35:38 +0000511 if (const_result)
512 const_result->TransferAddress();
Sean Callanan47dc4572011-09-15 02:13:07 +0000513 evaluated_statically = true;
Sean Callanan696cf5f2011-05-07 01:06:41 +0000514 err.Clear();
515 return err;
516 }
517
Greg Clayton567e7f32011-09-22 04:58:26 +0000518 Process *process = exe_ctx.GetProcessPtr();
519
520 if (!process || execution_policy == eExecutionPolicyNever)
Sean Callanan47dc4572011-09-15 02:13:07 +0000521 {
522 err.SetErrorToGenericError();
Sean Callananddf110d2012-01-24 22:06:48 +0000523 if (execution_policy == eExecutionPolicyAlways)
524 err.SetErrorString("Execution needed to run in the target, but the target can't be run");
525 else
526 err.SetErrorStringWithFormat("Interpreting the expression locally failed: %s", interpreter_error.AsCString());
Sean Callanan8f2e3922012-02-04 08:49:35 +0000527
Sean Callanan47dc4572011-09-15 02:13:07 +0000528 return err;
529 }
530
Sean Callanan6cf6c472011-09-20 23:01:51 +0000531 if (execution_policy != eExecutionPolicyNever &&
532 m_expr.NeedsValidation() &&
Greg Clayton567e7f32011-09-22 04:58:26 +0000533 process)
Sean Callananf18d91c2010-09-01 00:58:00 +0000534 {
Greg Clayton567e7f32011-09-22 04:58:26 +0000535 if (!process->GetDynamicCheckers())
Sean Callanan6cf6c472011-09-20 23:01:51 +0000536 {
537 DynamicCheckerFunctions *dynamic_checkers = new DynamicCheckerFunctions();
538
539 StreamString install_errors;
540
541 if (!dynamic_checkers->Install(install_errors, exe_ctx))
542 {
543 if (install_errors.GetString().empty())
544 err.SetErrorString ("couldn't install checkers, unknown error");
545 else
546 err.SetErrorString (install_errors.GetString().c_str());
547
548 return err;
549 }
550
Greg Clayton567e7f32011-09-22 04:58:26 +0000551 process->SetDynamicCheckers(dynamic_checkers);
Sean Callanan6cf6c472011-09-20 23:01:51 +0000552
553 if (log)
554 log->Printf("== [ClangUserExpression::Evaluate] Finished installing dynamic checkers ==");
555 }
556
Greg Clayton567e7f32011-09-22 04:58:26 +0000557 IRDynamicChecks ir_dynamic_checks(*process->GetDynamicCheckers(), function_name.c_str());
Sean Callanane8a59a82010-09-13 21:34:21 +0000558
559 if (!ir_dynamic_checks.runOnModule(*module))
560 {
561 err.SetErrorToGenericError();
562 err.SetErrorString("Couldn't add dynamic checks to the expression");
563 return err;
564 }
565 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000566 }
567
Greg Claytond0882d02011-01-19 23:00:49 +0000568 // llvm will own this pointer when llvm::ExecutionEngine::createJIT is called
569 // below so we don't need to free it.
570 RecordingMemoryManager *jit_memory_manager = new RecordingMemoryManager();
Sean Callanan65dafa82010-08-27 01:01:44 +0000571
572 std::string error_string;
Sean Callanan7b8eb762011-11-01 17:33:54 +0000573
574 if (log)
575 {
576 std::string s;
577 raw_string_ostream oss(s);
578
579 module->print(oss, NULL);
580
581 oss.flush();
582
583 log->Printf ("Module being sent to JIT: \n%s", s.c_str());
584 }
585
Greg Clayton2f085c62011-05-15 01:25:55 +0000586 EngineBuilder builder(module);
587 builder.setEngineKind(EngineKind::JIT)
588 .setErrorStr(&error_string)
Sean Callanan9b6898f2011-07-30 02:42:06 +0000589 .setRelocationModel(llvm::Reloc::PIC_)
Greg Clayton2f085c62011-05-15 01:25:55 +0000590 .setJITMemoryManager(jit_memory_manager)
591 .setOptLevel(CodeGenOpt::Less)
592 .setAllocateGVsWithCode(true)
593 .setCodeModel(CodeModel::Small)
Sean Callanan16b53ab2011-10-12 00:12:34 +0000594 .setUseMCJIT(true);
Sean Callananddf110d2012-01-24 22:06:48 +0000595 execution_engine.reset(builder.create());
Sean Callanan9ac3a962010-11-02 23:20:00 +0000596
Sean Callananddf110d2012-01-24 22:06:48 +0000597 if (!execution_engine.get())
Sean Callanan65dafa82010-08-27 01:01:44 +0000598 {
599 err.SetErrorToGenericError();
600 err.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
601 return err;
602 }
603
Sean Callananddf110d2012-01-24 22:06:48 +0000604 execution_engine->DisableLazyCompilation();
Sean Callanan65dafa82010-08-27 01:01:44 +0000605
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000606 llvm::Function *function = module->getFunction (function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000607
608 // We don't actually need the function pointer here, this just forces it to get resolved.
609
Sean Callananddf110d2012-01-24 22:06:48 +0000610 void *fun_ptr = execution_engine->getPointerToFunction(function);
611
Sean Callanan65dafa82010-08-27 01:01:44 +0000612 // Errors usually cause failures in the JIT, but if we're lucky we get here.
613
Sean Callanan7b8eb762011-11-01 17:33:54 +0000614 if (!function)
615 {
616 err.SetErrorToGenericError();
617 err.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", function_name.c_str());
618 return err;
619 }
620
Sean Callanan65dafa82010-08-27 01:01:44 +0000621 if (!fun_ptr)
622 {
623 err.SetErrorToGenericError();
Sean Callanan7b8eb762011-11-01 17:33:54 +0000624 err.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000625 return err;
626 }
627
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000628 m_jitted_functions.push_back (ClangExpressionParser::JittedFunction(function_name.c_str(), (lldb::addr_t)fun_ptr));
Sean Callanan65dafa82010-08-27 01:01:44 +0000629
Greg Clayton567e7f32011-09-22 04:58:26 +0000630
631 Process *process = exe_ctx.GetProcessPtr();
632 if (process == NULL)
Sean Callanan65dafa82010-08-27 01:01:44 +0000633 {
634 err.SetErrorToGenericError();
635 err.SetErrorString("Couldn't write the JIT compiled code into the target because there is no target");
636 return err;
637 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000638
Sean Callanan8f2e3922012-02-04 08:49:35 +0000639 jit_memory_manager->CommitAllocations(*process);
Sean Callanan142f94c2012-03-01 02:03:47 +0000640 jit_memory_manager->ReportAllocations(*execution_engine);
Sean Callanan8f2e3922012-02-04 08:49:35 +0000641 jit_memory_manager->WriteData(*process);
Sean Callanan65dafa82010-08-27 01:01:44 +0000642
643 std::vector<JittedFunction>::iterator pos, end = m_jitted_functions.end();
644
645 for (pos = m_jitted_functions.begin(); pos != end; pos++)
646 {
Greg Claytond0882d02011-01-19 23:00:49 +0000647 (*pos).m_remote_addr = jit_memory_manager->GetRemoteAddressForLocal ((*pos).m_local_addr);
Sean Callanan65dafa82010-08-27 01:01:44 +0000648
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000649 if (!(*pos).m_name.compare(function_name.c_str()))
Sean Callanan830a9032010-08-27 23:31:21 +0000650 {
Sean Callanan8f2e3922012-02-04 08:49:35 +0000651 RecordingMemoryManager::AddrRange func_range = jit_memory_manager->GetRemoteRangeForLocal((*pos).m_local_addr);
652 func_end = func_range.first + func_range.second;
Sean Callanan65dafa82010-08-27 01:01:44 +0000653 func_addr = (*pos).m_remote_addr;
Sean Callanan830a9032010-08-27 23:31:21 +0000654 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000655 }
656
Sean Callanan6dff8272010-11-08 03:49:50 +0000657 if (log)
658 {
659 log->Printf("Code can be run in the target.");
660
661 StreamString disassembly_stream;
662
Greg Claytond0882d02011-01-19 23:00:49 +0000663 Error err = DisassembleFunction(disassembly_stream, exe_ctx, jit_memory_manager);
Sean Callanan6dff8272010-11-08 03:49:50 +0000664
665 if (!err.Success())
666 {
667 log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error"));
668 }
669 else
670 {
671 log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
672 }
673 }
674
Sean Callananddf110d2012-01-24 22:06:48 +0000675 execution_engine.reset();
676
Sean Callanan65dafa82010-08-27 01:01:44 +0000677 err.Clear();
678 return err;
679}
680
681Error
Greg Claytond0882d02011-01-19 23:00:49 +0000682ClangExpressionParser::DisassembleFunction (Stream &stream, ExecutionContext &exe_ctx, RecordingMemoryManager *jit_memory_manager)
Sean Callanan65dafa82010-08-27 01:01:44 +0000683{
Greg Claytone005f2c2010-11-06 01:53:30 +0000684 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan65dafa82010-08-27 01:01:44 +0000685
686 const char *name = m_expr.FunctionName();
687
688 Error ret;
689
690 ret.Clear();
691
692 lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
693 lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
694
695 std::vector<JittedFunction>::iterator pos, end = m_jitted_functions.end();
696
697 for (pos = m_jitted_functions.begin(); pos < end; pos++)
698 {
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000699 if (strstr(pos->m_name.c_str(), name))
Sean Callanan65dafa82010-08-27 01:01:44 +0000700 {
701 func_local_addr = pos->m_local_addr;
702 func_remote_addr = pos->m_remote_addr;
703 }
704 }
705
706 if (func_local_addr == LLDB_INVALID_ADDRESS)
707 {
708 ret.SetErrorToGenericError();
709 ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", name);
710 return ret;
711 }
712
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000713 if (log)
Sean Callanan65dafa82010-08-27 01:01:44 +0000714 log->Printf("Found function, has local address 0x%llx and remote address 0x%llx", (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
715
716 std::pair <lldb::addr_t, lldb::addr_t> func_range;
717
Greg Claytond0882d02011-01-19 23:00:49 +0000718 func_range = jit_memory_manager->GetRemoteRangeForLocal(func_local_addr);
Sean Callanan65dafa82010-08-27 01:01:44 +0000719
720 if (func_range.first == 0 && func_range.second == 0)
721 {
722 ret.SetErrorToGenericError();
723 ret.SetErrorStringWithFormat("Couldn't find code range for function %s", name);
724 return ret;
725 }
726
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000727 if (log)
Sean Callanan8f2e3922012-02-04 08:49:35 +0000728 log->Printf("Function's code range is [0x%llx+0x%llx]", func_range.first, func_range.second);
Sean Callanan65dafa82010-08-27 01:01:44 +0000729
Greg Clayton567e7f32011-09-22 04:58:26 +0000730 Target *target = exe_ctx.GetTargetPtr();
731 if (!target)
Sean Callanan65dafa82010-08-27 01:01:44 +0000732 {
733 ret.SetErrorToGenericError();
734 ret.SetErrorString("Couldn't find the target");
735 }
736
Sean Callanan8f2e3922012-02-04 08:49:35 +0000737 lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
Sean Callanan65dafa82010-08-27 01:01:44 +0000738
Greg Clayton567e7f32011-09-22 04:58:26 +0000739 Process *process = exe_ctx.GetProcessPtr();
Sean Callanan65dafa82010-08-27 01:01:44 +0000740 Error err;
Greg Clayton567e7f32011-09-22 04:58:26 +0000741 process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err);
Sean Callanan65dafa82010-08-27 01:01:44 +0000742
743 if (!err.Success())
744 {
745 ret.SetErrorToGenericError();
746 ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error"));
747 return ret;
748 }
749
Greg Clayton567e7f32011-09-22 04:58:26 +0000750 ArchSpec arch(target->GetArchitecture());
Sean Callanan65dafa82010-08-27 01:01:44 +0000751
Greg Clayton149731c2011-03-25 18:03:16 +0000752 Disassembler *disassembler = Disassembler::FindPlugin(arch, NULL);
Sean Callanan65dafa82010-08-27 01:01:44 +0000753
754 if (disassembler == NULL)
755 {
756 ret.SetErrorToGenericError();
Greg Clayton940b1032011-02-23 00:35:02 +0000757 ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName());
Sean Callanan65dafa82010-08-27 01:01:44 +0000758 return ret;
759 }
760
Greg Clayton567e7f32011-09-22 04:58:26 +0000761 if (!process)
Sean Callanan65dafa82010-08-27 01:01:44 +0000762 {
763 ret.SetErrorToGenericError();
764 ret.SetErrorString("Couldn't find the process");
765 return ret;
766 }
767
768 DataExtractor extractor(buffer_sp,
Greg Clayton567e7f32011-09-22 04:58:26 +0000769 process->GetByteOrder(),
770 target->GetArchitecture().GetAddressByteSize());
Sean Callanan65dafa82010-08-27 01:01:44 +0000771
Greg Claytone005f2c2010-11-06 01:53:30 +0000772 if (log)
Sean Callanan65dafa82010-08-27 01:01:44 +0000773 {
774 log->Printf("Function data has contents:");
Greg Claytone005f2c2010-11-06 01:53:30 +0000775 extractor.PutToLog (log.get(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000776 0,
777 extractor.GetByteSize(),
778 func_remote_addr,
779 16,
780 DataExtractor::TypeUInt8);
781 }
782
Greg Clayton3508c382012-02-24 01:59:29 +0000783 disassembler->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false);
Sean Callanan65dafa82010-08-27 01:01:44 +0000784
Greg Clayton5c4c7462010-10-06 03:09:58 +0000785 InstructionList &instruction_list = disassembler->GetInstructionList();
Greg Clayton889fbd02011-03-26 19:14:58 +0000786 const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();
Sean Callanan65dafa82010-08-27 01:01:44 +0000787 for (uint32_t instruction_index = 0, num_instructions = instruction_list.GetSize();
788 instruction_index < num_instructions;
789 ++instruction_index)
790 {
Greg Clayton5c4c7462010-10-06 03:09:58 +0000791 Instruction *instruction = instruction_list.GetInstructionAtIndex(instruction_index).get();
Sean Callanan65dafa82010-08-27 01:01:44 +0000792 instruction->Dump (&stream,
Greg Clayton889fbd02011-03-26 19:14:58 +0000793 max_opcode_byte_size,
Greg Clayton5c4c7462010-10-06 03:09:58 +0000794 true,
Greg Clayton149731c2011-03-25 18:03:16 +0000795 true,
Greg Clayton5c4c7462010-10-06 03:09:58 +0000796 &exe_ctx,
Sean Callanan65dafa82010-08-27 01:01:44 +0000797 true);
798 stream.PutChar('\n');
Sean Callanan65dafa82010-08-27 01:01:44 +0000799 }
800
801 return ret;
802}