blob: 0df6a67c3a06d812d413e8a7ed073b65d7542c85 [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
Greg Clayton289afcb2012-02-18 05:35:26 +0000231 lldb::ProcessSP process_sp;
Greg Clayton395fc332011-02-15 21:59:32 +0000232 if (exe_scope)
Greg Clayton289afcb2012-02-18 05:35:26 +0000233 process_sp = exe_scope->CalculateProcess();
Greg Clayton395fc332011-02-15 21:59:32 +0000234
Greg Clayton289afcb2012-02-18 05:35:26 +0000235 if (process_sp && m_compiler->getLangOpts().ObjC1)
Sean Callananc7674af2011-01-17 23:42:46 +0000236 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000237 if (process_sp->GetObjCLanguageRuntime())
Sean Callananc7674af2011-01-17 23:42:46 +0000238 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000239 if (process_sp->GetObjCLanguageRuntime()->GetRuntimeVersion() == eAppleObjC_V2)
Sean Callananc7674af2011-01-17 23:42:46 +0000240 {
241 m_compiler->getLangOpts().ObjCNonFragileABI = true; // NOT i386
242 m_compiler->getLangOpts().ObjCNonFragileABI2 = true; // NOT i386
243 }
Sean Callanan6e12c7a2012-03-08 02:39:03 +0000244
245 if (process_sp->GetObjCLanguageRuntime()->HasNewLiteralsAndIndexing())
246 {
247 m_compiler->getLangOpts().DebuggerObjCLiteral = true;
248 }
Sean Callananc7674af2011-01-17 23:42:46 +0000249 }
250 }
Greg Claytonf51ed302011-01-15 01:32:14 +0000251
Sean Callanan65dafa82010-08-27 01:01:44 +0000252 m_compiler->getLangOpts().ThreadsafeStatics = false;
253 m_compiler->getLangOpts().AccessControl = false; // Debuggers get universal access
254 m_compiler->getLangOpts().DollarIdents = true; // $ indicates a persistent variable name
Sean Callanandaa6efe2011-12-21 22:22:58 +0000255
Sean Callanan65dafa82010-08-27 01:01:44 +0000256 // Set CodeGen options
257 m_compiler->getCodeGenOpts().EmitDeclMetadata = true;
258 m_compiler->getCodeGenOpts().InstrumentFunctions = false;
259
260 // Disable some warnings.
261 m_compiler->getDiagnosticOpts().Warnings.push_back("no-unused-value");
262
263 // Set the target triple.
Greg Clayton289afcb2012-02-18 05:35:26 +0000264 lldb::TargetSP target_sp;
Greg Clayton395fc332011-02-15 21:59:32 +0000265 if (exe_scope)
Greg Clayton289afcb2012-02-18 05:35:26 +0000266 target_sp = exe_scope->CalculateTarget();
Greg Clayton395fc332011-02-15 21:59:32 +0000267
268 // TODO: figure out what to really do when we don't have a valid target.
269 // Sometimes this will be ok to just use the host target triple (when we
270 // evaluate say "2+3", but other expressions like breakpoint conditions
271 // and other things that _are_ target specific really shouldn't just be
272 // using the host triple. This needs to be fixed in a better way.
Greg Clayton289afcb2012-02-18 05:35:26 +0000273 if (target_sp && target_sp->GetArchitecture().IsValid())
Sean Callanan2a8c3382011-04-14 02:01:31 +0000274 {
Greg Clayton289afcb2012-02-18 05:35:26 +0000275 std::string triple = target_sp->GetArchitecture().GetTriple().str();
Sean Callanan2a8c3382011-04-14 02:01:31 +0000276
277 int dash_count = 0;
Johnny Chen2bc9eb32011-07-19 19:48:13 +0000278 for (size_t i = 0; i < triple.size(); ++i)
Sean Callanan2a8c3382011-04-14 02:01:31 +0000279 {
280 if (triple[i] == '-')
281 dash_count++;
282 if (dash_count == 3)
283 {
284 triple.resize(i);
285 break;
286 }
287 }
288
289 m_compiler->getTargetOpts().Triple = triple;
290 }
Greg Clayton395fc332011-02-15 21:59:32 +0000291 else
Sean Callanan2a8c3382011-04-14 02:01:31 +0000292 {
Sean Callanan7537dce2011-11-04 22:46:46 +0000293 m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
Sean Callanan2a8c3382011-04-14 02:01:31 +0000294 }
295
Sean Callanan65dafa82010-08-27 01:01:44 +0000296 // 3. Set up various important bits of infrastructure.
297 m_compiler->createDiagnostics(0, 0);
298
299 // Create the target instance.
300 m_compiler->setTarget(TargetInfo::CreateTargetInfo(m_compiler->getDiagnostics(),
301 m_compiler->getTargetOpts()));
302
303 assert (m_compiler->hasTarget());
304
305 // Inform the target of the language options
306 //
307 // FIXME: We shouldn't need to do this, the target should be immutable once
308 // created. This complexity should be lifted elsewhere.
309 m_compiler->getTarget().setForcedLangOptions(m_compiler->getLangOpts());
310
311 // 4. Set up the diagnostic buffer for reporting errors
312
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000313 m_compiler->getDiagnostics().setClient(new clang::TextDiagnosticBuffer);
Sean Callanan65dafa82010-08-27 01:01:44 +0000314
315 // 5. Set up the source management objects inside the compiler
316
Greg Clayton22defe82010-12-02 23:20:03 +0000317 clang::FileSystemOptions file_system_options;
318 m_file_manager.reset(new clang::FileManager(file_system_options));
Sean Callanan8a3b0a82010-11-18 02:56:27 +0000319
Sean Callanan65dafa82010-08-27 01:01:44 +0000320 if (!m_compiler->hasSourceManager())
Greg Clayton22defe82010-12-02 23:20:03 +0000321 m_compiler->createSourceManager(*m_file_manager.get());
Sean Callanan65dafa82010-08-27 01:01:44 +0000322
323 m_compiler->createFileManager();
324 m_compiler->createPreprocessor();
325
326 // 6. Most of this we get from the CompilerInstance, but we
327 // also want to give the context an ExternalASTSource.
Sean Callananee8fc722010-11-19 20:20:02 +0000328 m_selector_table.reset(new SelectorTable());
Sean Callananc1535182011-10-07 23:18:13 +0000329 m_builtin_context.reset(new Builtin::Context());
Sean Callanan65dafa82010-08-27 01:01:44 +0000330
331 std::auto_ptr<clang::ASTContext> ast_context(new ASTContext(m_compiler->getLangOpts(),
332 m_compiler->getSourceManager(),
Sean Callananc1535182011-10-07 23:18:13 +0000333 &m_compiler->getTarget(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000334 m_compiler->getPreprocessor().getIdentifierTable(),
Sean Callananee8fc722010-11-19 20:20:02 +0000335 *m_selector_table.get(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000336 *m_builtin_context.get(),
337 0));
338
339 ClangExpressionDeclMap *decl_map = m_expr.DeclMap();
340
341 if (decl_map)
342 {
Sean Callananf76afff2011-10-28 23:38:38 +0000343 llvm::OwningPtr<clang::ExternalASTSource> ast_source(decl_map->CreateProxy());
344 decl_map->InstallASTContext(ast_context.get());
Sean Callanan65dafa82010-08-27 01:01:44 +0000345 ast_context->setExternalSource(ast_source);
346 }
347
348 m_compiler->setASTContext(ast_context.release());
349
Greg Clayton8de27c72010-10-15 22:48:33 +0000350 std::string module_name("$__lldb_module");
Sean Callanan65dafa82010-08-27 01:01:44 +0000351
Sean Callanan279584c2011-03-15 00:17:19 +0000352 m_llvm_context.reset(new LLVMContext());
Sean Callanan65dafa82010-08-27 01:01:44 +0000353 m_code_generator.reset(CreateLLVMCodeGen(m_compiler->getDiagnostics(),
354 module_name,
355 m_compiler->getCodeGenOpts(),
Sean Callanan279584c2011-03-15 00:17:19 +0000356 *m_llvm_context));
Sean Callanan65dafa82010-08-27 01:01:44 +0000357}
358
359ClangExpressionParser::~ClangExpressionParser()
360{
361}
362
363unsigned
364ClangExpressionParser::Parse (Stream &stream)
365{
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000366 TextDiagnosticBuffer *diag_buf = static_cast<TextDiagnosticBuffer*>(m_compiler->getDiagnostics().getClient());
367
368 diag_buf->FlushDiagnostics (m_compiler->getDiagnostics());
Sean Callanan65dafa82010-08-27 01:01:44 +0000369
370 MemoryBuffer *memory_buffer = MemoryBuffer::getMemBufferCopy(m_expr.Text(), __FUNCTION__);
Sean Callanan142f94c2012-03-01 02:03:47 +0000371 m_compiler->getSourceManager().createMainFileIDForMemBuffer (memory_buffer);
Sean Callanan65dafa82010-08-27 01:01:44 +0000372
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000373 diag_buf->BeginSourceFile(m_compiler->getLangOpts(), &m_compiler->getPreprocessor());
Sean Callanan65dafa82010-08-27 01:01:44 +0000374
375 ASTConsumer *ast_transformer = m_expr.ASTTransformer(m_code_generator.get());
376
377 if (ast_transformer)
378 ParseAST(m_compiler->getPreprocessor(), ast_transformer, m_compiler->getASTContext());
379 else
380 ParseAST(m_compiler->getPreprocessor(), m_code_generator.get(), m_compiler->getASTContext());
381
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000382 diag_buf->EndSourceFile();
Sean Callananfb3058e2011-05-12 23:54:16 +0000383
Sean Callanan65dafa82010-08-27 01:01:44 +0000384 TextDiagnosticBuffer::const_iterator diag_iterator;
385
386 int num_errors = 0;
Sean Callanan7617c292010-11-01 20:28:09 +0000387
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000388 for (diag_iterator = diag_buf->warn_begin();
389 diag_iterator != diag_buf->warn_end();
Sean Callanan65dafa82010-08-27 01:01:44 +0000390 ++diag_iterator)
391 stream.Printf("warning: %s\n", (*diag_iterator).second.c_str());
392
393 num_errors = 0;
394
Sean Callanan47a5c4c2010-09-23 03:01:22 +0000395 for (diag_iterator = diag_buf->err_begin();
396 diag_iterator != diag_buf->err_end();
Sean Callanan65dafa82010-08-27 01:01:44 +0000397 ++diag_iterator)
398 {
399 num_errors++;
400 stream.Printf("error: %s\n", (*diag_iterator).second.c_str());
401 }
402
Sean Callanan7617c292010-11-01 20:28:09 +0000403 for (diag_iterator = diag_buf->note_begin();
404 diag_iterator != diag_buf->note_end();
405 ++diag_iterator)
406 stream.Printf("note: %s\n", (*diag_iterator).second.c_str());
407
Sean Callananfb3058e2011-05-12 23:54:16 +0000408 if (!num_errors)
409 {
410 if (m_expr.DeclMap() && !m_expr.DeclMap()->ResolveUnknownTypes())
411 {
412 stream.Printf("error: Couldn't infer the type of a variable\n");
413 num_errors++;
414 }
415 }
416
Sean Callanan65dafa82010-08-27 01:01:44 +0000417 return num_errors;
418}
419
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000420static bool FindFunctionInModule (std::string &mangled_name,
421 llvm::Module *module,
422 const char *orig_name)
423{
424 for (llvm::Module::iterator fi = module->getFunctionList().begin(), fe = module->getFunctionList().end();
425 fi != fe;
426 ++fi)
427 {
428 if (fi->getName().str().find(orig_name) != std::string::npos)
429 {
430 mangled_name = fi->getName().str();
431 return true;
432 }
433 }
434
435 return false;
436}
437
Sean Callanan65dafa82010-08-27 01:01:44 +0000438Error
Sean Callanan47dc4572011-09-15 02:13:07 +0000439ClangExpressionParser::PrepareForExecution (lldb::addr_t &func_allocation_addr,
440 lldb::addr_t &func_addr,
441 lldb::addr_t &func_end,
442 ExecutionContext &exe_ctx,
443 IRForTarget::StaticDataAllocator *data_allocator,
444 bool &evaluated_statically,
445 lldb::ClangExpressionVariableSP &const_result,
446 ExecutionPolicy execution_policy)
Sean Callanan65dafa82010-08-27 01:01:44 +0000447{
Greg Claytond0882d02011-01-19 23:00:49 +0000448 func_allocation_addr = LLDB_INVALID_ADDRESS;
449 func_addr = LLDB_INVALID_ADDRESS;
450 func_end = LLDB_INVALID_ADDRESS;
Greg Claytone005f2c2010-11-06 01:53:30 +0000451 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000452
Sean Callananddf110d2012-01-24 22:06:48 +0000453 std::auto_ptr<llvm::ExecutionEngine> execution_engine;
454
Sean Callanan65dafa82010-08-27 01:01:44 +0000455 Error err;
456
457 llvm::Module *module = m_code_generator->ReleaseModule();
458
459 if (!module)
460 {
461 err.SetErrorToGenericError();
462 err.SetErrorString("IR doesn't contain a module");
463 return err;
464 }
465
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000466 // Find the actual name of the function (it's often mangled somehow)
467
468 std::string function_name;
469
470 if (!FindFunctionInModule(function_name, module, m_expr.FunctionName()))
471 {
472 err.SetErrorToGenericError();
473 err.SetErrorStringWithFormat("Couldn't find %s() in the module", m_expr.FunctionName());
474 return err;
475 }
476 else
477 {
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000478 if (log)
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000479 log->Printf("Found function %s for %s", function_name.c_str(), m_expr.FunctionName());
480 }
481
Sean Callanan65dafa82010-08-27 01:01:44 +0000482 ClangExpressionDeclMap *decl_map = m_expr.DeclMap(); // result can be NULL
483
484 if (decl_map)
485 {
Sean Callanan97c924e2011-01-27 01:07:04 +0000486 Stream *error_stream = NULL;
Greg Clayton567e7f32011-09-22 04:58:26 +0000487 Target *target = exe_ctx.GetTargetPtr();
488 if (target)
489 error_stream = &target->GetDebugger().GetErrorStream();
Sean Callanan97c924e2011-01-27 01:07:04 +0000490
Sean Callanan47dc4572011-09-15 02:13:07 +0000491 IRForTarget ir_for_target(decl_map,
Sean Callanane8a59a82010-09-13 21:34:21 +0000492 m_expr.NeedsVariableResolution(),
Sean Callanan47dc4572011-09-15 02:13:07 +0000493 execution_policy,
Sean Callanan05a5a1b2010-12-16 03:17:46 +0000494 const_result,
Sean Callananc0492742011-05-23 21:40:23 +0000495 data_allocator,
Sean Callanan97c924e2011-01-27 01:07:04 +0000496 error_stream,
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000497 function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000498
Sean Callanan8f2e3922012-02-04 08:49:35 +0000499 ir_for_target.runOnModule(*module);
Sean Callananf18d91c2010-09-01 00:58:00 +0000500
Sean Callananddf110d2012-01-24 22:06:48 +0000501 Error &interpreter_error(ir_for_target.getInterpreterError());
502
503 if (execution_policy != eExecutionPolicyAlways && interpreter_error.Success())
Sean Callanan696cf5f2011-05-07 01:06:41 +0000504 {
Johnny Chenc6134962012-01-06 00:35:38 +0000505 if (const_result)
506 const_result->TransferAddress();
Sean Callanan47dc4572011-09-15 02:13:07 +0000507 evaluated_statically = true;
Sean Callanan696cf5f2011-05-07 01:06:41 +0000508 err.Clear();
509 return err;
510 }
511
Greg Clayton567e7f32011-09-22 04:58:26 +0000512 Process *process = exe_ctx.GetProcessPtr();
513
514 if (!process || execution_policy == eExecutionPolicyNever)
Sean Callanan47dc4572011-09-15 02:13:07 +0000515 {
516 err.SetErrorToGenericError();
Sean Callananddf110d2012-01-24 22:06:48 +0000517 if (execution_policy == eExecutionPolicyAlways)
518 err.SetErrorString("Execution needed to run in the target, but the target can't be run");
519 else
520 err.SetErrorStringWithFormat("Interpreting the expression locally failed: %s", interpreter_error.AsCString());
Sean Callanan8f2e3922012-02-04 08:49:35 +0000521
Sean Callanan47dc4572011-09-15 02:13:07 +0000522 return err;
523 }
524
Sean Callanan6cf6c472011-09-20 23:01:51 +0000525 if (execution_policy != eExecutionPolicyNever &&
526 m_expr.NeedsValidation() &&
Greg Clayton567e7f32011-09-22 04:58:26 +0000527 process)
Sean Callananf18d91c2010-09-01 00:58:00 +0000528 {
Greg Clayton567e7f32011-09-22 04:58:26 +0000529 if (!process->GetDynamicCheckers())
Sean Callanan6cf6c472011-09-20 23:01:51 +0000530 {
531 DynamicCheckerFunctions *dynamic_checkers = new DynamicCheckerFunctions();
532
533 StreamString install_errors;
534
535 if (!dynamic_checkers->Install(install_errors, exe_ctx))
536 {
537 if (install_errors.GetString().empty())
538 err.SetErrorString ("couldn't install checkers, unknown error");
539 else
540 err.SetErrorString (install_errors.GetString().c_str());
541
542 return err;
543 }
544
Greg Clayton567e7f32011-09-22 04:58:26 +0000545 process->SetDynamicCheckers(dynamic_checkers);
Sean Callanan6cf6c472011-09-20 23:01:51 +0000546
547 if (log)
548 log->Printf("== [ClangUserExpression::Evaluate] Finished installing dynamic checkers ==");
549 }
550
Greg Clayton567e7f32011-09-22 04:58:26 +0000551 IRDynamicChecks ir_dynamic_checks(*process->GetDynamicCheckers(), function_name.c_str());
Sean Callanane8a59a82010-09-13 21:34:21 +0000552
553 if (!ir_dynamic_checks.runOnModule(*module))
554 {
555 err.SetErrorToGenericError();
556 err.SetErrorString("Couldn't add dynamic checks to the expression");
557 return err;
558 }
559 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000560 }
561
Greg Claytond0882d02011-01-19 23:00:49 +0000562 // llvm will own this pointer when llvm::ExecutionEngine::createJIT is called
563 // below so we don't need to free it.
564 RecordingMemoryManager *jit_memory_manager = new RecordingMemoryManager();
Sean Callanan65dafa82010-08-27 01:01:44 +0000565
566 std::string error_string;
Sean Callanan7b8eb762011-11-01 17:33:54 +0000567
568 if (log)
569 {
570 std::string s;
571 raw_string_ostream oss(s);
572
573 module->print(oss, NULL);
574
575 oss.flush();
576
577 log->Printf ("Module being sent to JIT: \n%s", s.c_str());
578 }
579
Greg Clayton2f085c62011-05-15 01:25:55 +0000580 EngineBuilder builder(module);
581 builder.setEngineKind(EngineKind::JIT)
582 .setErrorStr(&error_string)
Sean Callanan9b6898f2011-07-30 02:42:06 +0000583 .setRelocationModel(llvm::Reloc::PIC_)
Greg Clayton2f085c62011-05-15 01:25:55 +0000584 .setJITMemoryManager(jit_memory_manager)
585 .setOptLevel(CodeGenOpt::Less)
586 .setAllocateGVsWithCode(true)
587 .setCodeModel(CodeModel::Small)
Sean Callanan16b53ab2011-10-12 00:12:34 +0000588 .setUseMCJIT(true);
Sean Callananddf110d2012-01-24 22:06:48 +0000589 execution_engine.reset(builder.create());
Sean Callanan9ac3a962010-11-02 23:20:00 +0000590
Sean Callananddf110d2012-01-24 22:06:48 +0000591 if (!execution_engine.get())
Sean Callanan65dafa82010-08-27 01:01:44 +0000592 {
593 err.SetErrorToGenericError();
594 err.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
595 return err;
596 }
597
Sean Callananddf110d2012-01-24 22:06:48 +0000598 execution_engine->DisableLazyCompilation();
Sean Callanan65dafa82010-08-27 01:01:44 +0000599
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000600 llvm::Function *function = module->getFunction (function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000601
602 // We don't actually need the function pointer here, this just forces it to get resolved.
603
Sean Callananddf110d2012-01-24 22:06:48 +0000604 void *fun_ptr = execution_engine->getPointerToFunction(function);
605
Sean Callanan65dafa82010-08-27 01:01:44 +0000606 // Errors usually cause failures in the JIT, but if we're lucky we get here.
607
Sean Callanan7b8eb762011-11-01 17:33:54 +0000608 if (!function)
609 {
610 err.SetErrorToGenericError();
611 err.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", function_name.c_str());
612 return err;
613 }
614
Sean Callanan65dafa82010-08-27 01:01:44 +0000615 if (!fun_ptr)
616 {
617 err.SetErrorToGenericError();
Sean Callanan7b8eb762011-11-01 17:33:54 +0000618 err.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", function_name.c_str());
Sean Callanan65dafa82010-08-27 01:01:44 +0000619 return err;
620 }
621
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000622 m_jitted_functions.push_back (ClangExpressionParser::JittedFunction(function_name.c_str(), (lldb::addr_t)fun_ptr));
Sean Callanan65dafa82010-08-27 01:01:44 +0000623
Greg Clayton567e7f32011-09-22 04:58:26 +0000624
625 Process *process = exe_ctx.GetProcessPtr();
626 if (process == NULL)
Sean Callanan65dafa82010-08-27 01:01:44 +0000627 {
628 err.SetErrorToGenericError();
629 err.SetErrorString("Couldn't write the JIT compiled code into the target because there is no target");
630 return err;
631 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000632
Sean Callanan8f2e3922012-02-04 08:49:35 +0000633 jit_memory_manager->CommitAllocations(*process);
Sean Callanan142f94c2012-03-01 02:03:47 +0000634 jit_memory_manager->ReportAllocations(*execution_engine);
Sean Callanan8f2e3922012-02-04 08:49:35 +0000635 jit_memory_manager->WriteData(*process);
Sean Callanan65dafa82010-08-27 01:01:44 +0000636
637 std::vector<JittedFunction>::iterator pos, end = m_jitted_functions.end();
638
639 for (pos = m_jitted_functions.begin(); pos != end; pos++)
640 {
Greg Claytond0882d02011-01-19 23:00:49 +0000641 (*pos).m_remote_addr = jit_memory_manager->GetRemoteAddressForLocal ((*pos).m_local_addr);
Sean Callanan65dafa82010-08-27 01:01:44 +0000642
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000643 if (!(*pos).m_name.compare(function_name.c_str()))
Sean Callanan830a9032010-08-27 23:31:21 +0000644 {
Sean Callanan8f2e3922012-02-04 08:49:35 +0000645 RecordingMemoryManager::AddrRange func_range = jit_memory_manager->GetRemoteRangeForLocal((*pos).m_local_addr);
646 func_end = func_range.first + func_range.second;
Sean Callanan65dafa82010-08-27 01:01:44 +0000647 func_addr = (*pos).m_remote_addr;
Sean Callanan830a9032010-08-27 23:31:21 +0000648 }
Sean Callanan65dafa82010-08-27 01:01:44 +0000649 }
650
Sean Callanan6dff8272010-11-08 03:49:50 +0000651 if (log)
652 {
653 log->Printf("Code can be run in the target.");
654
655 StreamString disassembly_stream;
656
Greg Claytond0882d02011-01-19 23:00:49 +0000657 Error err = DisassembleFunction(disassembly_stream, exe_ctx, jit_memory_manager);
Sean Callanan6dff8272010-11-08 03:49:50 +0000658
659 if (!err.Success())
660 {
661 log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error"));
662 }
663 else
664 {
665 log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
666 }
667 }
668
Sean Callananddf110d2012-01-24 22:06:48 +0000669 execution_engine.reset();
670
Sean Callanan65dafa82010-08-27 01:01:44 +0000671 err.Clear();
672 return err;
673}
674
675Error
Greg Claytond0882d02011-01-19 23:00:49 +0000676ClangExpressionParser::DisassembleFunction (Stream &stream, ExecutionContext &exe_ctx, RecordingMemoryManager *jit_memory_manager)
Sean Callanan65dafa82010-08-27 01:01:44 +0000677{
Greg Claytone005f2c2010-11-06 01:53:30 +0000678 lldb::LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Sean Callanan65dafa82010-08-27 01:01:44 +0000679
680 const char *name = m_expr.FunctionName();
681
682 Error ret;
683
684 ret.Clear();
685
686 lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
687 lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
688
689 std::vector<JittedFunction>::iterator pos, end = m_jitted_functions.end();
690
691 for (pos = m_jitted_functions.begin(); pos < end; pos++)
692 {
Sean Callanan3c9c5eb2010-09-21 00:44:12 +0000693 if (strstr(pos->m_name.c_str(), name))
Sean Callanan65dafa82010-08-27 01:01:44 +0000694 {
695 func_local_addr = pos->m_local_addr;
696 func_remote_addr = pos->m_remote_addr;
697 }
698 }
699
700 if (func_local_addr == LLDB_INVALID_ADDRESS)
701 {
702 ret.SetErrorToGenericError();
703 ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", name);
704 return ret;
705 }
706
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000707 if (log)
Sean Callanan65dafa82010-08-27 01:01:44 +0000708 log->Printf("Found function, has local address 0x%llx and remote address 0x%llx", (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
709
710 std::pair <lldb::addr_t, lldb::addr_t> func_range;
711
Greg Claytond0882d02011-01-19 23:00:49 +0000712 func_range = jit_memory_manager->GetRemoteRangeForLocal(func_local_addr);
Sean Callanan65dafa82010-08-27 01:01:44 +0000713
714 if (func_range.first == 0 && func_range.second == 0)
715 {
716 ret.SetErrorToGenericError();
717 ret.SetErrorStringWithFormat("Couldn't find code range for function %s", name);
718 return ret;
719 }
720
Enrico Granata4c3fb4b2011-07-19 18:03:25 +0000721 if (log)
Sean Callanan8f2e3922012-02-04 08:49:35 +0000722 log->Printf("Function's code range is [0x%llx+0x%llx]", func_range.first, func_range.second);
Sean Callanan65dafa82010-08-27 01:01:44 +0000723
Greg Clayton567e7f32011-09-22 04:58:26 +0000724 Target *target = exe_ctx.GetTargetPtr();
725 if (!target)
Sean Callanan65dafa82010-08-27 01:01:44 +0000726 {
727 ret.SetErrorToGenericError();
728 ret.SetErrorString("Couldn't find the target");
729 }
730
Sean Callanan8f2e3922012-02-04 08:49:35 +0000731 lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
Sean Callanan65dafa82010-08-27 01:01:44 +0000732
Greg Clayton567e7f32011-09-22 04:58:26 +0000733 Process *process = exe_ctx.GetProcessPtr();
Sean Callanan65dafa82010-08-27 01:01:44 +0000734 Error err;
Greg Clayton567e7f32011-09-22 04:58:26 +0000735 process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err);
Sean Callanan65dafa82010-08-27 01:01:44 +0000736
737 if (!err.Success())
738 {
739 ret.SetErrorToGenericError();
740 ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error"));
741 return ret;
742 }
743
Greg Clayton567e7f32011-09-22 04:58:26 +0000744 ArchSpec arch(target->GetArchitecture());
Sean Callanan65dafa82010-08-27 01:01:44 +0000745
Greg Clayton149731c2011-03-25 18:03:16 +0000746 Disassembler *disassembler = Disassembler::FindPlugin(arch, NULL);
Sean Callanan65dafa82010-08-27 01:01:44 +0000747
748 if (disassembler == NULL)
749 {
750 ret.SetErrorToGenericError();
Greg Clayton940b1032011-02-23 00:35:02 +0000751 ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName());
Sean Callanan65dafa82010-08-27 01:01:44 +0000752 return ret;
753 }
754
Greg Clayton567e7f32011-09-22 04:58:26 +0000755 if (!process)
Sean Callanan65dafa82010-08-27 01:01:44 +0000756 {
757 ret.SetErrorToGenericError();
758 ret.SetErrorString("Couldn't find the process");
759 return ret;
760 }
761
762 DataExtractor extractor(buffer_sp,
Greg Clayton567e7f32011-09-22 04:58:26 +0000763 process->GetByteOrder(),
764 target->GetArchitecture().GetAddressByteSize());
Sean Callanan65dafa82010-08-27 01:01:44 +0000765
Greg Claytone005f2c2010-11-06 01:53:30 +0000766 if (log)
Sean Callanan65dafa82010-08-27 01:01:44 +0000767 {
768 log->Printf("Function data has contents:");
Greg Claytone005f2c2010-11-06 01:53:30 +0000769 extractor.PutToLog (log.get(),
Sean Callanan65dafa82010-08-27 01:01:44 +0000770 0,
771 extractor.GetByteSize(),
772 func_remote_addr,
773 16,
774 DataExtractor::TypeUInt8);
775 }
776
Greg Clayton3508c382012-02-24 01:59:29 +0000777 disassembler->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false);
Sean Callanan65dafa82010-08-27 01:01:44 +0000778
Greg Clayton5c4c7462010-10-06 03:09:58 +0000779 InstructionList &instruction_list = disassembler->GetInstructionList();
Greg Clayton889fbd02011-03-26 19:14:58 +0000780 const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();
Sean Callanan65dafa82010-08-27 01:01:44 +0000781 for (uint32_t instruction_index = 0, num_instructions = instruction_list.GetSize();
782 instruction_index < num_instructions;
783 ++instruction_index)
784 {
Greg Clayton5c4c7462010-10-06 03:09:58 +0000785 Instruction *instruction = instruction_list.GetInstructionAtIndex(instruction_index).get();
Sean Callanan65dafa82010-08-27 01:01:44 +0000786 instruction->Dump (&stream,
Greg Clayton889fbd02011-03-26 19:14:58 +0000787 max_opcode_byte_size,
Greg Clayton5c4c7462010-10-06 03:09:58 +0000788 true,
Greg Clayton149731c2011-03-25 18:03:16 +0000789 true,
Greg Clayton5c4c7462010-10-06 03:09:58 +0000790 &exe_ctx,
Sean Callanan65dafa82010-08-27 01:01:44 +0000791 true);
792 stream.PutChar('\n');
Sean Callanan65dafa82010-08-27 01:01:44 +0000793 }
794
795 return ret;
796}