1 //===-- IRForTarget.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/IRForTarget.h"
11
12 #include "llvm/Support/raw_ostream.h"
13 #include "llvm/IR/Constants.h"
14 #include "llvm/IR/DataLayout.h"
15 #include "llvm/IR/InstrTypes.h"
16 #include "llvm/IR/Instructions.h"
17 #include "llvm/IR/Intrinsics.h"
18 #include "llvm/IR/Module.h"
19 #include "llvm/PassManager.h"
20 #include "llvm/Transforms/IPO.h"
21 #include "llvm/IR/ValueSymbolTable.h"
22
23 #include "clang/AST/ASTContext.h"
24
25 #include "lldb/Core/dwarf.h"
26 #include "lldb/Core/ConstString.h"
27 #include "lldb/Core/DataBufferHeap.h"
28 #include "lldb/Core/Log.h"
29 #include "lldb/Core/Scalar.h"
30 #include "lldb/Core/StreamString.h"
31 #include "lldb/Expression/ClangExpressionDeclMap.h"
32 #include "lldb/Expression/IRExecutionUnit.h"
33 #include "lldb/Expression/IRInterpreter.h"
34 #include "lldb/Host/Endian.h"
35 #include "lldb/Symbol/ClangASTContext.h"
36 #include "lldb/Symbol/ClangASTType.h"
37
38 #include <map>
39
40 using namespace llvm;
41
42 static char ID;
43
StaticDataAllocator(lldb_private::IRExecutionUnit & execution_unit)44 IRForTarget::StaticDataAllocator::StaticDataAllocator(lldb_private::IRExecutionUnit &execution_unit) :
45 m_execution_unit(execution_unit),
46 m_stream_string(lldb_private::Stream::eBinary, execution_unit.GetAddressByteSize(), execution_unit.GetByteOrder()),
47 m_allocation(LLDB_INVALID_ADDRESS)
48 {
49 }
50
FunctionValueCache(Maker const & maker)51 IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker) :
52 m_maker(maker),
53 m_values()
54 {
55 }
56
~FunctionValueCache()57 IRForTarget::FunctionValueCache::~FunctionValueCache()
58 {
59 }
60
GetValue(llvm::Function * function)61 llvm::Value *IRForTarget::FunctionValueCache::GetValue(llvm::Function *function)
62 {
63 if (!m_values.count(function))
64 {
65 llvm::Value *ret = m_maker(function);
66 m_values[function] = ret;
67 return ret;
68 }
69 return m_values[function];
70 }
71
Allocate()72 lldb::addr_t IRForTarget::StaticDataAllocator::Allocate()
73 {
74 lldb_private::Error err;
75
76 if (m_allocation != LLDB_INVALID_ADDRESS)
77 {
78 m_execution_unit.FreeNow(m_allocation);
79 m_allocation = LLDB_INVALID_ADDRESS;
80 }
81
82 m_allocation = m_execution_unit.WriteNow((const uint8_t*)m_stream_string.GetData(), m_stream_string.GetSize(), err);
83
84 return m_allocation;
85 }
86
FindEntryInstruction(llvm::Function * function)87 static llvm::Value *FindEntryInstruction (llvm::Function *function)
88 {
89 if (function->empty())
90 return NULL;
91
92 return function->getEntryBlock().getFirstNonPHIOrDbg();
93 }
94
IRForTarget(lldb_private::ClangExpressionDeclMap * decl_map,bool resolve_vars,lldb_private::IRExecutionUnit & execution_unit,lldb_private::Stream * error_stream,const char * func_name)95 IRForTarget::IRForTarget (lldb_private::ClangExpressionDeclMap *decl_map,
96 bool resolve_vars,
97 lldb_private::IRExecutionUnit &execution_unit,
98 lldb_private::Stream *error_stream,
99 const char *func_name) :
100 ModulePass(ID),
101 m_resolve_vars(resolve_vars),
102 m_func_name(func_name),
103 m_module(NULL),
104 m_decl_map(decl_map),
105 m_data_allocator(execution_unit),
106 m_CFStringCreateWithBytes(NULL),
107 m_sel_registerName(NULL),
108 m_intptr_ty(NULL),
109 m_error_stream(error_stream),
110 m_result_store(NULL),
111 m_result_is_pointer(false),
112 m_reloc_placeholder(NULL),
113 m_entry_instruction_finder (FindEntryInstruction)
114 {
115 }
116
117 /* Handy utility functions used at several places in the code */
118
119 static std::string
PrintValue(const Value * value,bool truncate=false)120 PrintValue(const Value *value, bool truncate = false)
121 {
122 std::string s;
123 if (value)
124 {
125 raw_string_ostream rso(s);
126 value->print(rso);
127 rso.flush();
128 if (truncate)
129 s.resize(s.length() - 1);
130 }
131 return s;
132 }
133
134 static std::string
PrintType(const llvm::Type * type,bool truncate=false)135 PrintType(const llvm::Type *type, bool truncate = false)
136 {
137 std::string s;
138 raw_string_ostream rso(s);
139 type->print(rso);
140 rso.flush();
141 if (truncate)
142 s.resize(s.length() - 1);
143 return s;
144 }
145
~IRForTarget()146 IRForTarget::~IRForTarget()
147 {
148 }
149
150 bool
FixFunctionLinkage(llvm::Function & llvm_function)151 IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function)
152 {
153 llvm_function.setLinkage(GlobalValue::ExternalLinkage);
154
155 std::string name = llvm_function.getName().str();
156
157 return true;
158 }
159
160 bool
GetFunctionAddress(llvm::Function * fun,uint64_t & fun_addr,lldb_private::ConstString & name,Constant ** & value_ptr)161 IRForTarget::GetFunctionAddress (llvm::Function *fun,
162 uint64_t &fun_addr,
163 lldb_private::ConstString &name,
164 Constant **&value_ptr)
165 {
166 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
167
168 fun_addr = LLDB_INVALID_ADDRESS;
169 name.Clear();
170 value_ptr = NULL;
171
172 if (fun->isIntrinsic())
173 {
174 Intrinsic::ID intrinsic_id = (Intrinsic::ID)fun->getIntrinsicID();
175
176 switch (intrinsic_id)
177 {
178 default:
179 if (log)
180 log->Printf("Unresolved intrinsic \"%s\"", Intrinsic::getName(intrinsic_id).c_str());
181
182 if (m_error_stream)
183 m_error_stream->Printf("Internal error [IRForTarget]: Call to unhandled compiler intrinsic '%s'\n", Intrinsic::getName(intrinsic_id).c_str());
184
185 return false;
186 case Intrinsic::memcpy:
187 {
188 static lldb_private::ConstString g_memcpy_str ("memcpy");
189 name = g_memcpy_str;
190 }
191 break;
192 case Intrinsic::memset:
193 {
194 static lldb_private::ConstString g_memset_str ("memset");
195 name = g_memset_str;
196 }
197 break;
198 }
199
200 if (log && name)
201 log->Printf("Resolved intrinsic name \"%s\"", name.GetCString());
202 }
203 else
204 {
205 name.SetCStringWithLength (fun->getName().data(), fun->getName().size());
206 }
207
208 // Find the address of the function.
209
210 clang::NamedDecl *fun_decl = DeclForGlobal (fun);
211
212 if (fun_decl)
213 {
214 if (!m_decl_map->GetFunctionInfo (fun_decl, fun_addr))
215 {
216 lldb_private::ConstString altnernate_name;
217 bool found_it = m_decl_map->GetFunctionAddress (name, fun_addr);
218 if (!found_it)
219 {
220 // Check for an alternate mangling for "std::basic_string<char>"
221 // that is part of the itanium C++ name mangling scheme
222 const char *name_cstr = name.GetCString();
223 if (name_cstr && strncmp(name_cstr, "_ZNKSbIcE", strlen("_ZNKSbIcE")) == 0)
224 {
225 std::string alternate_mangling("_ZNKSs");
226 alternate_mangling.append (name_cstr + strlen("_ZNKSbIcE"));
227 altnernate_name.SetCString(alternate_mangling.c_str());
228 found_it = m_decl_map->GetFunctionAddress (altnernate_name, fun_addr);
229 }
230 }
231
232 if (!found_it)
233 {
234 lldb_private::Mangled mangled_name(name);
235 lldb_private::Mangled alt_mangled_name(altnernate_name);
236 if (log)
237 {
238 if (alt_mangled_name)
239 log->Printf("Function \"%s\" (alternate name \"%s\") has no address",
240 mangled_name.GetName().GetCString(),
241 alt_mangled_name.GetName().GetCString());
242 else
243 log->Printf("Function \"%s\" had no address",
244 mangled_name.GetName().GetCString());
245 }
246
247 if (m_error_stream)
248 {
249 if (alt_mangled_name)
250 m_error_stream->Printf("error: call to a function '%s' (alternate name '%s') that is not present in the target\n",
251 mangled_name.GetName().GetCString(),
252 alt_mangled_name.GetName().GetCString());
253 else if (mangled_name.GetMangledName())
254 m_error_stream->Printf("error: call to a function '%s' ('%s') that is not present in the target\n",
255 mangled_name.GetName().GetCString(),
256 mangled_name.GetMangledName().GetCString());
257 else
258 m_error_stream->Printf("error: call to a function '%s' that is not present in the target\n",
259 mangled_name.GetName().GetCString());
260 }
261 return false;
262 }
263 }
264 }
265 else
266 {
267 if (!m_decl_map->GetFunctionAddress (name, fun_addr))
268 {
269 if (log)
270 log->Printf ("Metadataless function \"%s\" had no address", name.GetCString());
271
272 if (m_error_stream)
273 m_error_stream->Printf("Error [IRForTarget]: Call to a symbol-only function '%s' that is not present in the target\n", name.GetCString());
274
275 return false;
276 }
277 }
278
279 if (log)
280 log->Printf("Found \"%s\" at 0x%" PRIx64, name.GetCString(), fun_addr);
281
282 return true;
283 }
284
285 llvm::Constant *
BuildFunctionPointer(llvm::Type * type,uint64_t ptr)286 IRForTarget::BuildFunctionPointer (llvm::Type *type,
287 uint64_t ptr)
288 {
289 PointerType *fun_ptr_ty = PointerType::getUnqual(type);
290 Constant *fun_addr_int = ConstantInt::get(m_intptr_ty, ptr, false);
291 return ConstantExpr::getIntToPtr(fun_addr_int, fun_ptr_ty);
292 }
293
294 void
RegisterFunctionMetadata(LLVMContext & context,llvm::Value * function_ptr,const char * name)295 IRForTarget::RegisterFunctionMetadata(LLVMContext &context,
296 llvm::Value *function_ptr,
297 const char *name)
298 {
299 for (Value::use_iterator i = function_ptr->use_begin(), e = function_ptr->use_end();
300 i != e;
301 ++i)
302 {
303 Value *user = *i;
304
305 if (Instruction *user_inst = dyn_cast<Instruction>(user))
306 {
307 MDString* md_name = MDString::get(context, StringRef(name));
308
309 MDNode *metadata = MDNode::get(context, md_name);
310
311 user_inst->setMetadata("lldb.call.realName", metadata);
312 }
313 else
314 {
315 RegisterFunctionMetadata (context, user, name);
316 }
317 }
318 }
319
320 bool
ResolveFunctionPointers(llvm::Module & llvm_module)321 IRForTarget::ResolveFunctionPointers(llvm::Module &llvm_module)
322 {
323 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
324
325 for (llvm::Module::iterator fi = llvm_module.begin();
326 fi != llvm_module.end();
327 ++fi)
328 {
329 Function *fun = fi;
330
331 bool is_decl = fun->isDeclaration();
332
333 if (log)
334 log->Printf("Examining %s function %s", (is_decl ? "declaration" : "non-declaration"), fun->getName().str().c_str());
335
336 if (!is_decl)
337 continue;
338
339 if (fun->hasNUses(0))
340 continue; // ignore
341
342 uint64_t addr = LLDB_INVALID_ADDRESS;
343 lldb_private::ConstString name;
344 Constant **value_ptr = NULL;
345
346 if (!GetFunctionAddress(fun,
347 addr,
348 name,
349 value_ptr))
350 return false; // GetFunctionAddress reports its own errors
351
352 Constant *value = BuildFunctionPointer(fun->getFunctionType(), addr);
353
354 RegisterFunctionMetadata (llvm_module.getContext(), fun, name.AsCString());
355
356 if (value_ptr)
357 *value_ptr = value;
358
359 // If we are replacing a function with the nobuiltin attribute, it may
360 // be called with the builtin attribute on call sites. Remove any such
361 // attributes since it's illegal to have a builtin call to something
362 // other than a nobuiltin function.
363 if (fun->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
364 llvm::Attribute builtin = llvm::Attribute::get(fun->getContext(), llvm::Attribute::Builtin);
365
366 for (auto u = fun->use_begin(), e = fun->use_end(); u != e; ++u) {
367 if (auto call = dyn_cast<CallInst>(*u)) {
368 call->removeAttribute(AttributeSet::FunctionIndex, builtin);
369 }
370 }
371 }
372
373 fun->replaceAllUsesWith(value);
374 }
375
376 return true;
377 }
378
379
380 clang::NamedDecl *
DeclForGlobal(const GlobalValue * global_val,Module * module)381 IRForTarget::DeclForGlobal (const GlobalValue *global_val, Module *module)
382 {
383 NamedMDNode *named_metadata = module->getNamedMetadata("clang.global.decl.ptrs");
384
385 if (!named_metadata)
386 return NULL;
387
388 unsigned num_nodes = named_metadata->getNumOperands();
389 unsigned node_index;
390
391 for (node_index = 0;
392 node_index < num_nodes;
393 ++node_index)
394 {
395 MDNode *metadata_node = named_metadata->getOperand(node_index);
396
397 if (!metadata_node)
398 return NULL;
399
400 if (metadata_node->getNumOperands() != 2)
401 continue;
402
403 if (metadata_node->getOperand(0) != global_val)
404 continue;
405
406 ConstantInt *constant_int = dyn_cast<ConstantInt>(metadata_node->getOperand(1));
407
408 if (!constant_int)
409 return NULL;
410
411 uintptr_t ptr = constant_int->getZExtValue();
412
413 return reinterpret_cast<clang::NamedDecl *>(ptr);
414 }
415
416 return NULL;
417 }
418
419 clang::NamedDecl *
DeclForGlobal(GlobalValue * global_val)420 IRForTarget::DeclForGlobal (GlobalValue *global_val)
421 {
422 return DeclForGlobal(global_val, m_module);
423 }
424
425 bool
CreateResultVariable(llvm::Function & llvm_function)426 IRForTarget::CreateResultVariable (llvm::Function &llvm_function)
427 {
428 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
429
430 if (!m_resolve_vars)
431 return true;
432
433 // Find the result variable. If it doesn't exist, we can give up right here.
434
435 ValueSymbolTable& value_symbol_table = m_module->getValueSymbolTable();
436
437 std::string result_name_str;
438 const char *result_name = NULL;
439
440 for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
441 vi != ve;
442 ++vi)
443 {
444 result_name_str = vi->first().str();
445 const char *value_name = result_name_str.c_str();
446
447 if (strstr(value_name, "$__lldb_expr_result_ptr") &&
448 strncmp(value_name, "_ZGV", 4))
449 {
450 result_name = value_name;
451 m_result_is_pointer = true;
452 break;
453 }
454
455 if (strstr(value_name, "$__lldb_expr_result") &&
456 strncmp(value_name, "_ZGV", 4))
457 {
458 result_name = value_name;
459 m_result_is_pointer = false;
460 break;
461 }
462 }
463
464 if (!result_name)
465 {
466 if (log)
467 log->PutCString("Couldn't find result variable");
468
469 return true;
470 }
471
472 if (log)
473 log->Printf("Result name: \"%s\"", result_name);
474
475 Value *result_value = m_module->getNamedValue(result_name);
476
477 if (!result_value)
478 {
479 if (log)
480 log->PutCString("Result variable had no data");
481
482 if (m_error_stream)
483 m_error_stream->Printf("Internal error [IRForTarget]: Result variable's name (%s) exists, but not its definition\n", result_name);
484
485 return false;
486 }
487
488 if (log)
489 log->Printf("Found result in the IR: \"%s\"", PrintValue(result_value, false).c_str());
490
491 GlobalVariable *result_global = dyn_cast<GlobalVariable>(result_value);
492
493 if (!result_global)
494 {
495 if (log)
496 log->PutCString("Result variable isn't a GlobalVariable");
497
498 if (m_error_stream)
499 m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) is defined, but is not a global variable\n", result_name);
500
501 return false;
502 }
503
504 clang::NamedDecl *result_decl = DeclForGlobal (result_global);
505 if (!result_decl)
506 {
507 if (log)
508 log->PutCString("Result variable doesn't have a corresponding Decl");
509
510 if (m_error_stream)
511 m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) does not have a corresponding Clang entity\n", result_name);
512
513 return false;
514 }
515
516 if (log)
517 {
518 std::string decl_desc_str;
519 raw_string_ostream decl_desc_stream(decl_desc_str);
520 result_decl->print(decl_desc_stream);
521 decl_desc_stream.flush();
522
523 log->Printf("Found result decl: \"%s\"", decl_desc_str.c_str());
524 }
525
526 clang::VarDecl *result_var = dyn_cast<clang::VarDecl>(result_decl);
527 if (!result_var)
528 {
529 if (log)
530 log->PutCString("Result variable Decl isn't a VarDecl");
531
532 if (m_error_stream)
533 m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s)'s corresponding Clang entity isn't a variable\n", result_name);
534
535 return false;
536 }
537
538 // Get the next available result name from m_decl_map and create the persistent
539 // variable for it
540
541 // If the result is an Lvalue, it is emitted as a pointer; see
542 // ASTResultSynthesizer::SynthesizeBodyResult.
543 if (m_result_is_pointer)
544 {
545 clang::QualType pointer_qual_type = result_var->getType();
546 const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
547
548 const clang::PointerType *pointer_pointertype = pointer_type->getAs<clang::PointerType>();
549 const clang::ObjCObjectPointerType *pointer_objcobjpointertype = pointer_type->getAs<clang::ObjCObjectPointerType>();
550
551 if (pointer_pointertype)
552 {
553 clang::QualType element_qual_type = pointer_pointertype->getPointeeType();
554
555 m_result_type = lldb_private::TypeFromParser(element_qual_type.getAsOpaquePtr(),
556 &result_decl->getASTContext());
557 }
558 else if (pointer_objcobjpointertype)
559 {
560 clang::QualType element_qual_type = clang::QualType(pointer_objcobjpointertype->getObjectType(), 0);
561
562 m_result_type = lldb_private::TypeFromParser(element_qual_type.getAsOpaquePtr(),
563 &result_decl->getASTContext());
564 }
565 else
566 {
567 if (log)
568 log->PutCString("Expected result to have pointer type, but it did not");
569
570 if (m_error_stream)
571 m_error_stream->Printf("Internal error [IRForTarget]: Lvalue result (%s) is not a pointer variable\n", result_name);
572
573 return false;
574 }
575 }
576 else
577 {
578 m_result_type = lldb_private::TypeFromParser(result_var->getType().getAsOpaquePtr(),
579 &result_decl->getASTContext());
580 }
581
582 if (m_result_type.GetBitSize() == 0)
583 {
584 lldb_private::StreamString type_desc_stream;
585 m_result_type.DumpTypeDescription(&type_desc_stream);
586
587 if (log)
588 log->Printf("Result type has size 0");
589
590 if (m_error_stream)
591 m_error_stream->Printf("Error [IRForTarget]: Size of result type '%s' couldn't be determined\n",
592 type_desc_stream.GetData());
593 return false;
594 }
595
596 if (log)
597 {
598 lldb_private::StreamString type_desc_stream;
599 m_result_type.DumpTypeDescription(&type_desc_stream);
600
601 log->Printf("Result decl type: \"%s\"", type_desc_stream.GetData());
602 }
603
604 m_result_name = lldb_private::ConstString("$RESULT_NAME");
605
606 if (log)
607 log->Printf("Creating a new result global: \"%s\" with size 0x%" PRIx64,
608 m_result_name.GetCString(),
609 m_result_type.GetByteSize());
610
611 // Construct a new result global and set up its metadata
612
613 GlobalVariable *new_result_global = new GlobalVariable((*m_module),
614 result_global->getType()->getElementType(),
615 false, /* not constant */
616 GlobalValue::ExternalLinkage,
617 NULL, /* no initializer */
618 m_result_name.GetCString ());
619
620 // It's too late in compilation to create a new VarDecl for this, but we don't
621 // need to. We point the metadata at the old VarDecl. This creates an odd
622 // anomaly: a variable with a Value whose name is something like $0 and a
623 // Decl whose name is $__lldb_expr_result. This condition is handled in
624 // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
625 // fixed up.
626
627 ConstantInt *new_constant_int = ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
628 reinterpret_cast<uint64_t>(result_decl),
629 false);
630
631 llvm::Value* values[2];
632 values[0] = new_result_global;
633 values[1] = new_constant_int;
634
635 ArrayRef<Value*> value_ref(values, 2);
636
637 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
638 NamedMDNode *named_metadata = m_module->getNamedMetadata("clang.global.decl.ptrs");
639 named_metadata->addOperand(persistent_global_md);
640
641 if (log)
642 log->Printf("Replacing \"%s\" with \"%s\"",
643 PrintValue(result_global).c_str(),
644 PrintValue(new_result_global).c_str());
645
646 if (result_global->hasNUses(0))
647 {
648 // We need to synthesize a store for this variable, because otherwise
649 // there's nothing to put into its equivalent persistent variable.
650
651 BasicBlock &entry_block(llvm_function.getEntryBlock());
652 Instruction *first_entry_instruction(entry_block.getFirstNonPHIOrDbg());
653
654 if (!first_entry_instruction)
655 return false;
656
657 if (!result_global->hasInitializer())
658 {
659 if (log)
660 log->Printf("Couldn't find initializer for unused variable");
661
662 if (m_error_stream)
663 m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) has no writes and no initializer\n", result_name);
664
665 return false;
666 }
667
668 Constant *initializer = result_global->getInitializer();
669
670 StoreInst *synthesized_store = new StoreInst(initializer,
671 new_result_global,
672 first_entry_instruction);
673
674 if (log)
675 log->Printf("Synthesized result store \"%s\"\n", PrintValue(synthesized_store).c_str());
676 }
677 else
678 {
679 result_global->replaceAllUsesWith(new_result_global);
680 }
681
682 if (!m_decl_map->AddPersistentVariable(result_decl,
683 m_result_name,
684 m_result_type,
685 true,
686 m_result_is_pointer))
687 return false;
688
689 result_global->eraseFromParent();
690
691 return true;
692 }
693
694 #if 0
695 static void DebugUsers(Log *log, Value *value, uint8_t depth)
696 {
697 if (!depth)
698 return;
699
700 depth--;
701
702 if (log)
703 log->Printf(" <Begin %d users>", value->getNumUses());
704
705 for (Value::use_iterator ui = value->use_begin(), ue = value->use_end();
706 ui != ue;
707 ++ui)
708 {
709 if (log)
710 log->Printf(" <Use %p> %s", *ui, PrintValue(*ui).c_str());
711 DebugUsers(log, *ui, depth);
712 }
713
714 if (log)
715 log->Printf(" <End uses>");
716 }
717 #endif
718
719 bool
RewriteObjCConstString(llvm::GlobalVariable * ns_str,llvm::GlobalVariable * cstr)720 IRForTarget::RewriteObjCConstString (llvm::GlobalVariable *ns_str,
721 llvm::GlobalVariable *cstr)
722 {
723 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
724
725 Type *ns_str_ty = ns_str->getType();
726
727 Type *i8_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
728 Type *i32_ty = Type::getInt32Ty(m_module->getContext());
729 Type *i8_ty = Type::getInt8Ty(m_module->getContext());
730
731 if (!m_CFStringCreateWithBytes)
732 {
733 lldb::addr_t CFStringCreateWithBytes_addr;
734
735 static lldb_private::ConstString g_CFStringCreateWithBytes_str ("CFStringCreateWithBytes");
736
737 if (!m_decl_map->GetFunctionAddress (g_CFStringCreateWithBytes_str, CFStringCreateWithBytes_addr))
738 {
739 if (log)
740 log->PutCString("Couldn't find CFStringCreateWithBytes in the target");
741
742 if (m_error_stream)
743 m_error_stream->Printf("Error [IRForTarget]: Rewriting an Objective-C constant string requires CFStringCreateWithBytes\n");
744
745 return false;
746 }
747
748 if (log)
749 log->Printf("Found CFStringCreateWithBytes at 0x%" PRIx64, CFStringCreateWithBytes_addr);
750
751 // Build the function type:
752 //
753 // CFStringRef CFStringCreateWithBytes (
754 // CFAllocatorRef alloc,
755 // const UInt8 *bytes,
756 // CFIndex numBytes,
757 // CFStringEncoding encoding,
758 // Boolean isExternalRepresentation
759 // );
760 //
761 // We make the following substitutions:
762 //
763 // CFStringRef -> i8*
764 // CFAllocatorRef -> i8*
765 // UInt8 * -> i8*
766 // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its pointer size for now)
767 // CFStringEncoding -> i32
768 // Boolean -> i8
769
770 Type *arg_type_array[5];
771
772 arg_type_array[0] = i8_ptr_ty;
773 arg_type_array[1] = i8_ptr_ty;
774 arg_type_array[2] = m_intptr_ty;
775 arg_type_array[3] = i32_ty;
776 arg_type_array[4] = i8_ty;
777
778 ArrayRef<Type *> CFSCWB_arg_types(arg_type_array, 5);
779
780 llvm::Type *CFSCWB_ty = FunctionType::get(ns_str_ty, CFSCWB_arg_types, false);
781
782 // Build the constant containing the pointer to the function
783 PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
784 Constant *CFSCWB_addr_int = ConstantInt::get(m_intptr_ty, CFStringCreateWithBytes_addr, false);
785 m_CFStringCreateWithBytes = ConstantExpr::getIntToPtr(CFSCWB_addr_int, CFSCWB_ptr_ty);
786 }
787
788 ConstantDataSequential *string_array = NULL;
789
790 if (cstr)
791 string_array = dyn_cast<ConstantDataSequential>(cstr->getInitializer());
792
793 Constant *alloc_arg = Constant::getNullValue(i8_ptr_ty);
794 Constant *bytes_arg = cstr ? ConstantExpr::getBitCast(cstr, i8_ptr_ty) : Constant::getNullValue(i8_ptr_ty);
795 Constant *numBytes_arg = ConstantInt::get(m_intptr_ty, cstr ? string_array->getNumElements() - 1 : 0, false);
796 Constant *encoding_arg = ConstantInt::get(i32_ty, 0x0600, false); /* 0x0600 is kCFStringEncodingASCII */
797 Constant *isExternal_arg = ConstantInt::get(i8_ty, 0x0, false); /* 0x0 is false */
798
799 Value *argument_array[5];
800
801 argument_array[0] = alloc_arg;
802 argument_array[1] = bytes_arg;
803 argument_array[2] = numBytes_arg;
804 argument_array[3] = encoding_arg;
805 argument_array[4] = isExternal_arg;
806
807 ArrayRef <Value *> CFSCWB_arguments(argument_array, 5);
808
809 FunctionValueCache CFSCWB_Caller ([this, &CFSCWB_arguments] (llvm::Function *function)->llvm::Value * {
810 return CallInst::Create(m_CFStringCreateWithBytes,
811 CFSCWB_arguments,
812 "CFStringCreateWithBytes",
813 llvm::cast<Instruction>(m_entry_instruction_finder.GetValue(function)));
814 });
815
816 if (!UnfoldConstant(ns_str, CFSCWB_Caller, m_entry_instruction_finder))
817 {
818 if (log)
819 log->PutCString("Couldn't replace the NSString with the result of the call");
820
821 if (m_error_stream)
822 m_error_stream->Printf("Error [IRForTarget]: Couldn't replace an Objective-C constant string with a dynamic string\n");
823
824 return false;
825 }
826
827 ns_str->eraseFromParent();
828
829 return true;
830 }
831
832 bool
RewriteObjCConstStrings()833 IRForTarget::RewriteObjCConstStrings()
834 {
835 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
836
837 ValueSymbolTable& value_symbol_table = m_module->getValueSymbolTable();
838
839 for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
840 vi != ve;
841 ++vi)
842 {
843 std::string value_name = vi->first().str();
844 const char *value_name_cstr = value_name.c_str();
845
846 if (strstr(value_name_cstr, "_unnamed_cfstring_"))
847 {
848 Value *nsstring_value = vi->second;
849
850 GlobalVariable *nsstring_global = dyn_cast<GlobalVariable>(nsstring_value);
851
852 if (!nsstring_global)
853 {
854 if (log)
855 log->PutCString("NSString variable is not a GlobalVariable");
856
857 if (m_error_stream)
858 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string is not a global variable\n");
859
860 return false;
861 }
862
863 if (!nsstring_global->hasInitializer())
864 {
865 if (log)
866 log->PutCString("NSString variable does not have an initializer");
867
868 if (m_error_stream)
869 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string does not have an initializer\n");
870
871 return false;
872 }
873
874 ConstantStruct *nsstring_struct = dyn_cast<ConstantStruct>(nsstring_global->getInitializer());
875
876 if (!nsstring_struct)
877 {
878 if (log)
879 log->PutCString("NSString variable's initializer is not a ConstantStruct");
880
881 if (m_error_stream)
882 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string is not a structure constant\n");
883
884 return false;
885 }
886
887 // We expect the following structure:
888 //
889 // struct {
890 // int *isa;
891 // int flags;
892 // char *str;
893 // long length;
894 // };
895
896 if (nsstring_struct->getNumOperands() != 4)
897 {
898 if (log)
899 log->Printf("NSString variable's initializer structure has an unexpected number of members. Should be 4, is %d", nsstring_struct->getNumOperands());
900
901 if (m_error_stream)
902 m_error_stream->Printf("Internal error [IRForTarget]: The struct for an Objective-C constant string is not as expected\n");
903
904 return false;
905 }
906
907 Constant *nsstring_member = nsstring_struct->getOperand(2);
908
909 if (!nsstring_member)
910 {
911 if (log)
912 log->PutCString("NSString initializer's str element was empty");
913
914 if (m_error_stream)
915 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string does not have a string initializer\n");
916
917 return false;
918 }
919
920 ConstantExpr *nsstring_expr = dyn_cast<ConstantExpr>(nsstring_member);
921
922 if (!nsstring_expr)
923 {
924 if (log)
925 log->PutCString("NSString initializer's str element is not a ConstantExpr");
926
927 if (m_error_stream)
928 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer is not constant\n");
929
930 return false;
931 }
932
933 if (nsstring_expr->getOpcode() != Instruction::GetElementPtr)
934 {
935 if (log)
936 log->Printf("NSString initializer's str element is not a GetElementPtr expression, it's a %s", nsstring_expr->getOpcodeName());
937
938 if (m_error_stream)
939 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer is not an array\n");
940
941 return false;
942 }
943
944 Constant *nsstring_cstr = nsstring_expr->getOperand(0);
945
946 GlobalVariable *cstr_global = dyn_cast<GlobalVariable>(nsstring_cstr);
947
948 if (!cstr_global)
949 {
950 if (log)
951 log->PutCString("NSString initializer's str element is not a GlobalVariable");
952
953 if (m_error_stream)
954 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to a global\n");
955
956 return false;
957 }
958
959 if (!cstr_global->hasInitializer())
960 {
961 if (log)
962 log->PutCString("NSString initializer's str element does not have an initializer");
963
964 if (m_error_stream)
965 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to initialized data\n");
966
967 return false;
968 }
969
970 /*
971 if (!cstr_array)
972 {
973 if (log)
974 log->PutCString("NSString initializer's str element is not a ConstantArray");
975
976 if (m_error_stream)
977 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to an array\n");
978
979 return false;
980 }
981
982 if (!cstr_array->isCString())
983 {
984 if (log)
985 log->PutCString("NSString initializer's str element is not a C string array");
986
987 if (m_error_stream)
988 m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to a C string\n");
989
990 return false;
991 }
992 */
993
994 ConstantDataArray *cstr_array = dyn_cast<ConstantDataArray>(cstr_global->getInitializer());
995
996 if (log)
997 {
998 if (cstr_array)
999 log->Printf("Found NSString constant %s, which contains \"%s\"", value_name_cstr, cstr_array->getAsString().str().c_str());
1000 else
1001 log->Printf("Found NSString constant %s, which contains \"\"", value_name_cstr);
1002 }
1003
1004 if (!cstr_array)
1005 cstr_global = NULL;
1006
1007 if (!RewriteObjCConstString(nsstring_global, cstr_global))
1008 {
1009 if (log)
1010 log->PutCString("Error rewriting the constant string");
1011
1012 // We don't print an error message here because RewriteObjCConstString has done so for us.
1013
1014 return false;
1015 }
1016 }
1017 }
1018
1019 for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
1020 vi != ve;
1021 ++vi)
1022 {
1023 std::string value_name = vi->first().str();
1024 const char *value_name_cstr = value_name.c_str();
1025
1026 if (!strcmp(value_name_cstr, "__CFConstantStringClassReference"))
1027 {
1028 GlobalVariable *gv = dyn_cast<GlobalVariable>(vi->second);
1029
1030 if (!gv)
1031 {
1032 if (log)
1033 log->PutCString("__CFConstantStringClassReference is not a global variable");
1034
1035 if (m_error_stream)
1036 m_error_stream->Printf("Internal error [IRForTarget]: Found a CFConstantStringClassReference, but it is not a global object\n");
1037
1038 return false;
1039 }
1040
1041 gv->eraseFromParent();
1042
1043 break;
1044 }
1045 }
1046
1047 return true;
1048 }
1049
IsObjCSelectorRef(Value * value)1050 static bool IsObjCSelectorRef (Value *value)
1051 {
1052 GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
1053
1054 if (!global_variable || !global_variable->hasName() || !global_variable->getName().startswith("\01L_OBJC_SELECTOR_REFERENCES_"))
1055 return false;
1056
1057 return true;
1058 }
1059
1060 // This function does not report errors; its callers are responsible.
1061 bool
RewriteObjCSelector(Instruction * selector_load)1062 IRForTarget::RewriteObjCSelector (Instruction* selector_load)
1063 {
1064 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1065
1066 LoadInst *load = dyn_cast<LoadInst>(selector_load);
1067
1068 if (!load)
1069 return false;
1070
1071 // Unpack the message name from the selector. In LLVM IR, an objc_msgSend gets represented as
1072 //
1073 // %tmp = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" ; <i8*>
1074 // %call = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...) ; <i8*>
1075 //
1076 // where %obj is the object pointer and %tmp is the selector.
1077 //
1078 // @"\01L_OBJC_SELECTOR_REFERENCES_" is a pointer to a character array called @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_".
1079 // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_" contains the string.
1080
1081 // Find the pointer's initializer (a ConstantExpr with opcode GetElementPtr) and get the string from its target
1082
1083 GlobalVariable *_objc_selector_references_ = dyn_cast<GlobalVariable>(load->getPointerOperand());
1084
1085 if (!_objc_selector_references_ || !_objc_selector_references_->hasInitializer())
1086 return false;
1087
1088 Constant *osr_initializer = _objc_selector_references_->getInitializer();
1089
1090 ConstantExpr *osr_initializer_expr = dyn_cast<ConstantExpr>(osr_initializer);
1091
1092 if (!osr_initializer_expr || osr_initializer_expr->getOpcode() != Instruction::GetElementPtr)
1093 return false;
1094
1095 Value *osr_initializer_base = osr_initializer_expr->getOperand(0);
1096
1097 if (!osr_initializer_base)
1098 return false;
1099
1100 // Find the string's initializer (a ConstantArray) and get the string from it
1101
1102 GlobalVariable *_objc_meth_var_name_ = dyn_cast<GlobalVariable>(osr_initializer_base);
1103
1104 if (!_objc_meth_var_name_ || !_objc_meth_var_name_->hasInitializer())
1105 return false;
1106
1107 Constant *omvn_initializer = _objc_meth_var_name_->getInitializer();
1108
1109 ConstantDataArray *omvn_initializer_array = dyn_cast<ConstantDataArray>(omvn_initializer);
1110
1111 if (!omvn_initializer_array->isString())
1112 return false;
1113
1114 std::string omvn_initializer_string = omvn_initializer_array->getAsString();
1115
1116 if (log)
1117 log->Printf("Found Objective-C selector reference \"%s\"", omvn_initializer_string.c_str());
1118
1119 // Construct a call to sel_registerName
1120
1121 if (!m_sel_registerName)
1122 {
1123 lldb::addr_t sel_registerName_addr;
1124
1125 static lldb_private::ConstString g_sel_registerName_str ("sel_registerName");
1126 if (!m_decl_map->GetFunctionAddress (g_sel_registerName_str, sel_registerName_addr))
1127 return false;
1128
1129 if (log)
1130 log->Printf("Found sel_registerName at 0x%" PRIx64, sel_registerName_addr);
1131
1132 // Build the function type: struct objc_selector *sel_registerName(uint8_t*)
1133
1134 // The below code would be "more correct," but in actuality what's required is uint8_t*
1135 //Type *sel_type = StructType::get(m_module->getContext());
1136 //Type *sel_ptr_type = PointerType::getUnqual(sel_type);
1137 Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
1138
1139 Type *type_array[1];
1140
1141 type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
1142
1143 ArrayRef<Type *> srN_arg_types(type_array, 1);
1144
1145 llvm::Type *srN_type = FunctionType::get(sel_ptr_type, srN_arg_types, false);
1146
1147 // Build the constant containing the pointer to the function
1148 PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
1149 Constant *srN_addr_int = ConstantInt::get(m_intptr_ty, sel_registerName_addr, false);
1150 m_sel_registerName = ConstantExpr::getIntToPtr(srN_addr_int, srN_ptr_ty);
1151 }
1152
1153 Value *argument_array[1];
1154
1155 Constant *omvn_pointer = ConstantExpr::getBitCast(_objc_meth_var_name_, Type::getInt8PtrTy(m_module->getContext()));
1156
1157 argument_array[0] = omvn_pointer;
1158
1159 ArrayRef<Value *> srN_arguments(argument_array, 1);
1160
1161 CallInst *srN_call = CallInst::Create(m_sel_registerName,
1162 srN_arguments,
1163 "sel_registerName",
1164 selector_load);
1165
1166 // Replace the load with the call in all users
1167
1168 selector_load->replaceAllUsesWith(srN_call);
1169
1170 selector_load->eraseFromParent();
1171
1172 return true;
1173 }
1174
1175 bool
RewriteObjCSelectors(BasicBlock & basic_block)1176 IRForTarget::RewriteObjCSelectors (BasicBlock &basic_block)
1177 {
1178 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1179
1180 BasicBlock::iterator ii;
1181
1182 typedef SmallVector <Instruction*, 2> InstrList;
1183 typedef InstrList::iterator InstrIterator;
1184
1185 InstrList selector_loads;
1186
1187 for (ii = basic_block.begin();
1188 ii != basic_block.end();
1189 ++ii)
1190 {
1191 Instruction &inst = *ii;
1192
1193 if (LoadInst *load = dyn_cast<LoadInst>(&inst))
1194 if (IsObjCSelectorRef(load->getPointerOperand()))
1195 selector_loads.push_back(&inst);
1196 }
1197
1198 InstrIterator iter;
1199
1200 for (iter = selector_loads.begin();
1201 iter != selector_loads.end();
1202 ++iter)
1203 {
1204 if (!RewriteObjCSelector(*iter))
1205 {
1206 if (m_error_stream)
1207 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't change a static reference to an Objective-C selector to a dynamic reference\n");
1208
1209 if (log)
1210 log->PutCString("Couldn't rewrite a reference to an Objective-C selector");
1211
1212 return false;
1213 }
1214 }
1215
1216 return true;
1217 }
1218
1219 // This function does not report errors; its callers are responsible.
1220 bool
RewritePersistentAlloc(llvm::Instruction * persistent_alloc)1221 IRForTarget::RewritePersistentAlloc (llvm::Instruction *persistent_alloc)
1222 {
1223 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1224
1225 AllocaInst *alloc = dyn_cast<AllocaInst>(persistent_alloc);
1226
1227 MDNode *alloc_md = alloc->getMetadata("clang.decl.ptr");
1228
1229 if (!alloc_md || !alloc_md->getNumOperands())
1230 return false;
1231
1232 ConstantInt *constant_int = dyn_cast<ConstantInt>(alloc_md->getOperand(0));
1233
1234 if (!constant_int)
1235 return false;
1236
1237 // We attempt to register this as a new persistent variable with the DeclMap.
1238
1239 uintptr_t ptr = constant_int->getZExtValue();
1240
1241 clang::VarDecl *decl = reinterpret_cast<clang::VarDecl *>(ptr);
1242
1243 lldb_private::TypeFromParser result_decl_type (decl->getType().getAsOpaquePtr(),
1244 &decl->getASTContext());
1245
1246 StringRef decl_name (decl->getName());
1247 lldb_private::ConstString persistent_variable_name (decl_name.data(), decl_name.size());
1248 if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name, result_decl_type, false, false))
1249 return false;
1250
1251 GlobalVariable *persistent_global = new GlobalVariable((*m_module),
1252 alloc->getType(),
1253 false, /* not constant */
1254 GlobalValue::ExternalLinkage,
1255 NULL, /* no initializer */
1256 alloc->getName().str().c_str());
1257
1258 // What we're going to do here is make believe this was a regular old external
1259 // variable. That means we need to make the metadata valid.
1260
1261 NamedMDNode *named_metadata = m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
1262
1263 llvm::Value* values[2];
1264 values[0] = persistent_global;
1265 values[1] = constant_int;
1266
1267 ArrayRef<llvm::Value*> value_ref(values, 2);
1268
1269 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
1270 named_metadata->addOperand(persistent_global_md);
1271
1272 // Now, since the variable is a pointer variable, we will drop in a load of that
1273 // pointer variable.
1274
1275 LoadInst *persistent_load = new LoadInst (persistent_global, "", alloc);
1276
1277 if (log)
1278 log->Printf("Replacing \"%s\" with \"%s\"",
1279 PrintValue(alloc).c_str(),
1280 PrintValue(persistent_load).c_str());
1281
1282 alloc->replaceAllUsesWith(persistent_load);
1283 alloc->eraseFromParent();
1284
1285 return true;
1286 }
1287
1288 bool
RewritePersistentAllocs(llvm::BasicBlock & basic_block)1289 IRForTarget::RewritePersistentAllocs(llvm::BasicBlock &basic_block)
1290 {
1291 if (!m_resolve_vars)
1292 return true;
1293
1294 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1295
1296 BasicBlock::iterator ii;
1297
1298 typedef SmallVector <Instruction*, 2> InstrList;
1299 typedef InstrList::iterator InstrIterator;
1300
1301 InstrList pvar_allocs;
1302
1303 for (ii = basic_block.begin();
1304 ii != basic_block.end();
1305 ++ii)
1306 {
1307 Instruction &inst = *ii;
1308
1309 if (AllocaInst *alloc = dyn_cast<AllocaInst>(&inst))
1310 {
1311 llvm::StringRef alloc_name = alloc->getName();
1312
1313 if (alloc_name.startswith("$") &&
1314 !alloc_name.startswith("$__lldb"))
1315 {
1316 if (alloc_name.find_first_of("0123456789") == 1)
1317 {
1318 if (log)
1319 log->Printf("Rejecting a numeric persistent variable.");
1320
1321 if (m_error_stream)
1322 m_error_stream->Printf("Error [IRForTarget]: Names starting with $0, $1, ... are reserved for use as result names\n");
1323
1324 return false;
1325 }
1326
1327 pvar_allocs.push_back(alloc);
1328 }
1329 }
1330 }
1331
1332 InstrIterator iter;
1333
1334 for (iter = pvar_allocs.begin();
1335 iter != pvar_allocs.end();
1336 ++iter)
1337 {
1338 if (!RewritePersistentAlloc(*iter))
1339 {
1340 if (m_error_stream)
1341 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite the creation of a persistent variable\n");
1342
1343 if (log)
1344 log->PutCString("Couldn't rewrite the creation of a persistent variable");
1345
1346 return false;
1347 }
1348 }
1349
1350 return true;
1351 }
1352
1353 bool
MaterializeInitializer(uint8_t * data,Constant * initializer)1354 IRForTarget::MaterializeInitializer (uint8_t *data, Constant *initializer)
1355 {
1356 if (!initializer)
1357 return true;
1358
1359 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1360
1361 if (log && log->GetVerbose())
1362 log->Printf(" MaterializeInitializer(%p, %s)", data, PrintValue(initializer).c_str());
1363
1364 Type *initializer_type = initializer->getType();
1365
1366 if (ConstantInt *int_initializer = dyn_cast<ConstantInt>(initializer))
1367 {
1368 memcpy (data, int_initializer->getValue().getRawData(), m_target_data->getTypeStoreSize(initializer_type));
1369 return true;
1370 }
1371 else if (ConstantDataArray *array_initializer = dyn_cast<ConstantDataArray>(initializer))
1372 {
1373 if (array_initializer->isString())
1374 {
1375 std::string array_initializer_string = array_initializer->getAsString();
1376 memcpy (data, array_initializer_string.c_str(), m_target_data->getTypeStoreSize(initializer_type));
1377 }
1378 else
1379 {
1380 ArrayType *array_initializer_type = array_initializer->getType();
1381 Type *array_element_type = array_initializer_type->getElementType();
1382
1383 size_t element_size = m_target_data->getTypeAllocSize(array_element_type);
1384
1385 for (unsigned i = 0; i < array_initializer->getNumOperands(); ++i)
1386 {
1387 Value *operand_value = array_initializer->getOperand(i);
1388 Constant *operand_constant = dyn_cast<Constant>(operand_value);
1389
1390 if (!operand_constant)
1391 return false;
1392
1393 if (!MaterializeInitializer(data + (i * element_size), operand_constant))
1394 return false;
1395 }
1396 }
1397 return true;
1398 }
1399 else if (ConstantStruct *struct_initializer = dyn_cast<ConstantStruct>(initializer))
1400 {
1401 StructType *struct_initializer_type = struct_initializer->getType();
1402 const StructLayout *struct_layout = m_target_data->getStructLayout(struct_initializer_type);
1403
1404 for (unsigned i = 0;
1405 i < struct_initializer->getNumOperands();
1406 ++i)
1407 {
1408 if (!MaterializeInitializer(data + struct_layout->getElementOffset(i), struct_initializer->getOperand(i)))
1409 return false;
1410 }
1411 return true;
1412 }
1413 else if (isa<ConstantAggregateZero>(initializer))
1414 {
1415 memset(data, 0, m_target_data->getTypeStoreSize(initializer_type));
1416 return true;
1417 }
1418 return false;
1419 }
1420
1421 bool
MaterializeInternalVariable(GlobalVariable * global_variable)1422 IRForTarget::MaterializeInternalVariable (GlobalVariable *global_variable)
1423 {
1424 if (GlobalVariable::isExternalLinkage(global_variable->getLinkage()))
1425 return false;
1426
1427 if (global_variable == m_reloc_placeholder)
1428 return true;
1429
1430 uint64_t offset = m_data_allocator.GetStream().GetSize();
1431
1432 llvm::Type *variable_type = global_variable->getType();
1433
1434 Constant *initializer = global_variable->getInitializer();
1435
1436 llvm::Type *initializer_type = initializer->getType();
1437
1438 size_t size = m_target_data->getTypeAllocSize(initializer_type);
1439 size_t align = m_target_data->getPrefTypeAlignment(initializer_type);
1440
1441 const size_t mask = (align - 1);
1442 uint64_t aligned_offset = (offset + mask) & ~mask;
1443 m_data_allocator.GetStream().PutNHex8(aligned_offset - offset, 0);
1444 offset = aligned_offset;
1445
1446 lldb_private::DataBufferHeap data(size, '\0');
1447
1448 if (initializer)
1449 if (!MaterializeInitializer(data.GetBytes(), initializer))
1450 return false;
1451
1452 m_data_allocator.GetStream().Write(data.GetBytes(), data.GetByteSize());
1453
1454 Constant *new_pointer = BuildRelocation(variable_type, offset);
1455
1456 global_variable->replaceAllUsesWith(new_pointer);
1457
1458 global_variable->eraseFromParent();
1459
1460 return true;
1461 }
1462
1463 // This function does not report errors; its callers are responsible.
1464 bool
MaybeHandleVariable(Value * llvm_value_ptr)1465 IRForTarget::MaybeHandleVariable (Value *llvm_value_ptr)
1466 {
1467 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1468
1469 if (log)
1470 log->Printf("MaybeHandleVariable (%s)", PrintValue(llvm_value_ptr).c_str());
1471
1472 if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(llvm_value_ptr))
1473 {
1474 switch (constant_expr->getOpcode())
1475 {
1476 default:
1477 break;
1478 case Instruction::GetElementPtr:
1479 case Instruction::BitCast:
1480 Value *s = constant_expr->getOperand(0);
1481 if (!MaybeHandleVariable(s))
1482 return false;
1483 }
1484 }
1485 else if (GlobalVariable *global_variable = dyn_cast<GlobalVariable>(llvm_value_ptr))
1486 {
1487 if (!GlobalValue::isExternalLinkage(global_variable->getLinkage()))
1488 return MaterializeInternalVariable(global_variable);
1489
1490 clang::NamedDecl *named_decl = DeclForGlobal(global_variable);
1491
1492 if (!named_decl)
1493 {
1494 if (IsObjCSelectorRef(llvm_value_ptr))
1495 return true;
1496
1497 if (!global_variable->hasExternalLinkage())
1498 return true;
1499
1500 if (log)
1501 log->Printf("Found global variable \"%s\" without metadata", global_variable->getName().str().c_str());
1502
1503 return false;
1504 }
1505
1506 std::string name (named_decl->getName().str());
1507
1508 clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl);
1509 if (value_decl == NULL)
1510 return false;
1511
1512 lldb_private::ClangASTType clang_type(&value_decl->getASTContext(), value_decl->getType());
1513
1514 const Type *value_type = NULL;
1515
1516 if (name[0] == '$')
1517 {
1518 // The $__lldb_expr_result name indicates the the return value has allocated as
1519 // a static variable. Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
1520 // accesses to this static variable need to be redirected to the result of dereferencing
1521 // a pointer that is passed in as one of the arguments.
1522 //
1523 // Consequently, when reporting the size of the type, we report a pointer type pointing
1524 // to the type of $__lldb_expr_result, not the type itself.
1525 //
1526 // We also do this for any user-declared persistent variables.
1527 clang_type = clang_type.GetPointerType();
1528 value_type = PointerType::get(global_variable->getType(), 0);
1529 }
1530 else
1531 {
1532 value_type = global_variable->getType();
1533 }
1534
1535 const uint64_t value_size = clang_type.GetByteSize();
1536 off_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull;
1537
1538 if (log)
1539 {
1540 log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRId64 "]",
1541 name.c_str(),
1542 clang_type.GetQualType().getAsString().c_str(),
1543 PrintType(value_type).c_str(),
1544 value_size,
1545 value_alignment);
1546 }
1547
1548
1549 if (named_decl && !m_decl_map->AddValueToStruct(named_decl,
1550 lldb_private::ConstString (name.c_str()),
1551 llvm_value_ptr,
1552 value_size,
1553 value_alignment))
1554 {
1555 if (!global_variable->hasExternalLinkage())
1556 return true;
1557 else if (HandleSymbol (global_variable))
1558 return true;
1559 else
1560 return false;
1561 }
1562 }
1563 else if (dyn_cast<llvm::Function>(llvm_value_ptr))
1564 {
1565 if (log)
1566 log->Printf("Function pointers aren't handled right now");
1567
1568 return false;
1569 }
1570
1571 return true;
1572 }
1573
1574 // This function does not report errors; its callers are responsible.
1575 bool
HandleSymbol(Value * symbol)1576 IRForTarget::HandleSymbol (Value *symbol)
1577 {
1578 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1579
1580 lldb_private::ConstString name(symbol->getName().str().c_str());
1581
1582 lldb::addr_t symbol_addr = m_decl_map->GetSymbolAddress (name, lldb::eSymbolTypeAny);
1583
1584 if (symbol_addr == LLDB_INVALID_ADDRESS)
1585 {
1586 if (log)
1587 log->Printf ("Symbol \"%s\" had no address", name.GetCString());
1588
1589 return false;
1590 }
1591
1592 if (log)
1593 log->Printf("Found \"%s\" at 0x%" PRIx64, name.GetCString(), symbol_addr);
1594
1595 Type *symbol_type = symbol->getType();
1596
1597 Constant *symbol_addr_int = ConstantInt::get(m_intptr_ty, symbol_addr, false);
1598
1599 Value *symbol_addr_ptr = ConstantExpr::getIntToPtr(symbol_addr_int, symbol_type);
1600
1601 if (log)
1602 log->Printf("Replacing %s with %s", PrintValue(symbol).c_str(), PrintValue(symbol_addr_ptr).c_str());
1603
1604 symbol->replaceAllUsesWith(symbol_addr_ptr);
1605
1606 return true;
1607 }
1608
1609 bool
MaybeHandleCallArguments(CallInst * Old)1610 IRForTarget::MaybeHandleCallArguments (CallInst *Old)
1611 {
1612 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1613
1614 if (log)
1615 log->Printf("MaybeHandleCallArguments(%s)", PrintValue(Old).c_str());
1616
1617 for (unsigned op_index = 0, num_ops = Old->getNumArgOperands();
1618 op_index < num_ops;
1619 ++op_index)
1620 if (!MaybeHandleVariable(Old->getArgOperand(op_index))) // conservatively believe that this is a store
1621 {
1622 if (m_error_stream)
1623 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite one of the arguments of a function call.\n");
1624
1625 return false;
1626 }
1627
1628 return true;
1629 }
1630
1631 bool
HandleObjCClass(Value * classlist_reference)1632 IRForTarget::HandleObjCClass(Value *classlist_reference)
1633 {
1634 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1635
1636 GlobalVariable *global_variable = dyn_cast<GlobalVariable>(classlist_reference);
1637
1638 if (!global_variable)
1639 return false;
1640
1641 Constant *initializer = global_variable->getInitializer();
1642
1643 if (!initializer)
1644 return false;
1645
1646 if (!initializer->hasName())
1647 return false;
1648
1649 StringRef name(initializer->getName());
1650 lldb_private::ConstString name_cstr(name.str().c_str());
1651 lldb::addr_t class_ptr = m_decl_map->GetSymbolAddress(name_cstr, lldb::eSymbolTypeObjCClass);
1652
1653 if (log)
1654 log->Printf("Found reference to Objective-C class %s (0x%llx)", name_cstr.AsCString(), (unsigned long long)class_ptr);
1655
1656 if (class_ptr == LLDB_INVALID_ADDRESS)
1657 return false;
1658
1659 if (global_variable->use_begin() == global_variable->use_end())
1660 return false;
1661
1662 SmallVector<LoadInst *, 2> load_instructions;
1663
1664 for (Value::use_iterator i = global_variable->use_begin(), e = global_variable->use_end();
1665 i != e;
1666 ++i)
1667 {
1668 if (LoadInst *load_instruction = dyn_cast<LoadInst>(*i))
1669 load_instructions.push_back(load_instruction);
1670 }
1671
1672 if (load_instructions.empty())
1673 return false;
1674
1675 Constant *class_addr = ConstantInt::get(m_intptr_ty, (uint64_t)class_ptr);
1676
1677 for (LoadInst *load_instruction : load_instructions)
1678 {
1679 Constant *class_bitcast = ConstantExpr::getIntToPtr(class_addr, load_instruction->getType());
1680
1681 load_instruction->replaceAllUsesWith(class_bitcast);
1682
1683 load_instruction->eraseFromParent();
1684 }
1685
1686 return true;
1687 }
1688
1689 bool
RemoveCXAAtExit(BasicBlock & basic_block)1690 IRForTarget::RemoveCXAAtExit (BasicBlock &basic_block)
1691 {
1692 BasicBlock::iterator ii;
1693
1694 std::vector<CallInst *> calls_to_remove;
1695
1696 for (ii = basic_block.begin();
1697 ii != basic_block.end();
1698 ++ii)
1699 {
1700 Instruction &inst = *ii;
1701
1702 CallInst *call = dyn_cast<CallInst>(&inst);
1703
1704 // MaybeHandleCallArguments handles error reporting; we are silent here
1705 if (!call)
1706 continue;
1707
1708 bool remove = false;
1709
1710 llvm::Function *func = call->getCalledFunction();
1711
1712 if (func && func->getName() == "__cxa_atexit")
1713 remove = true;
1714
1715 llvm::Value *val = call->getCalledValue();
1716
1717 if (val && val->getName() == "__cxa_atexit")
1718 remove = true;
1719
1720 if (remove)
1721 calls_to_remove.push_back(call);
1722 }
1723
1724 for (std::vector<CallInst *>::iterator ci = calls_to_remove.begin(), ce = calls_to_remove.end();
1725 ci != ce;
1726 ++ci)
1727 {
1728 (*ci)->eraseFromParent();
1729 }
1730
1731 return true;
1732 }
1733
1734 bool
ResolveCalls(BasicBlock & basic_block)1735 IRForTarget::ResolveCalls(BasicBlock &basic_block)
1736 {
1737 /////////////////////////////////////////////////////////////////////////
1738 // Prepare the current basic block for execution in the remote process
1739 //
1740
1741 BasicBlock::iterator ii;
1742
1743 for (ii = basic_block.begin();
1744 ii != basic_block.end();
1745 ++ii)
1746 {
1747 Instruction &inst = *ii;
1748
1749 CallInst *call = dyn_cast<CallInst>(&inst);
1750
1751 // MaybeHandleCallArguments handles error reporting; we are silent here
1752 if (call && !MaybeHandleCallArguments(call))
1753 return false;
1754 }
1755
1756 return true;
1757 }
1758
1759 bool
ResolveExternals(Function & llvm_function)1760 IRForTarget::ResolveExternals (Function &llvm_function)
1761 {
1762 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1763
1764 for (Module::global_iterator global = m_module->global_begin(), end = m_module->global_end();
1765 global != end;
1766 ++global)
1767 {
1768 if (!global)
1769 {
1770 if (m_error_stream)
1771 m_error_stream->Printf("Internal error [IRForTarget]: global variable is NULL");
1772
1773 return false;
1774 }
1775
1776 std::string global_name = (*global).getName().str();
1777
1778 if (log)
1779 log->Printf("Examining %s, DeclForGlobalValue returns %p",
1780 global_name.c_str(),
1781 DeclForGlobal(global));
1782
1783 if (global_name.find("OBJC_IVAR") == 0)
1784 {
1785 if (!HandleSymbol(global))
1786 {
1787 if (m_error_stream)
1788 m_error_stream->Printf("Error [IRForTarget]: Couldn't find Objective-C indirect ivar symbol %s\n", global_name.c_str());
1789
1790 return false;
1791 }
1792 }
1793 else if (global_name.find("OBJC_CLASSLIST_REFERENCES_$") != global_name.npos)
1794 {
1795 if (!HandleObjCClass(global))
1796 {
1797 if (m_error_stream)
1798 m_error_stream->Printf("Error [IRForTarget]: Couldn't resolve the class for an Objective-C static method call\n");
1799
1800 return false;
1801 }
1802 }
1803 else if (global_name.find("OBJC_CLASSLIST_SUP_REFS_$") != global_name.npos)
1804 {
1805 if (!HandleObjCClass(global))
1806 {
1807 if (m_error_stream)
1808 m_error_stream->Printf("Error [IRForTarget]: Couldn't resolve the class for an Objective-C static method call\n");
1809
1810 return false;
1811 }
1812 }
1813 else if (DeclForGlobal(global))
1814 {
1815 if (!MaybeHandleVariable (global))
1816 {
1817 if (m_error_stream)
1818 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite external variable %s\n", global_name.c_str());
1819
1820 return false;
1821 }
1822 }
1823 }
1824
1825 return true;
1826 }
1827
1828 bool
ReplaceStrings()1829 IRForTarget::ReplaceStrings ()
1830 {
1831 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1832
1833 typedef std::map <GlobalVariable *, size_t> OffsetsTy;
1834
1835 OffsetsTy offsets;
1836
1837 for (Module::global_iterator gi = m_module->global_begin(), ge = m_module->global_end();
1838 gi != ge;
1839 ++gi)
1840 {
1841 GlobalVariable *gv = gi;
1842
1843 if (!gv->hasInitializer())
1844 continue;
1845
1846 Constant *gc = gv->getInitializer();
1847
1848 std::string str;
1849
1850 if (gc->isNullValue())
1851 {
1852 Type *gc_type = gc->getType();
1853
1854 ArrayType *gc_array_type = dyn_cast<ArrayType>(gc_type);
1855
1856 if (!gc_array_type)
1857 continue;
1858
1859 Type *gc_element_type = gc_array_type->getElementType();
1860
1861 IntegerType *gc_integer_type = dyn_cast<IntegerType>(gc_element_type);
1862
1863 if (gc_integer_type->getBitWidth() != 8)
1864 continue;
1865
1866 str = "";
1867 }
1868 else
1869 {
1870 ConstantDataArray *gc_array = dyn_cast<ConstantDataArray>(gc);
1871
1872 if (!gc_array)
1873 continue;
1874
1875 if (!gc_array->isCString())
1876 continue;
1877
1878 if (log)
1879 log->Printf("Found a GlobalVariable with string initializer %s", PrintValue(gc).c_str());
1880
1881 str = gc_array->getAsString();
1882 }
1883
1884 offsets[gv] = m_data_allocator.GetStream().GetSize();
1885
1886 m_data_allocator.GetStream().Write(str.c_str(), str.length() + 1);
1887 }
1888
1889 Type *char_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
1890
1891 for (OffsetsTy::iterator oi = offsets.begin(), oe = offsets.end();
1892 oi != oe;
1893 ++oi)
1894 {
1895 GlobalVariable *gv = oi->first;
1896 size_t offset = oi->second;
1897
1898 Constant *new_initializer = BuildRelocation(char_ptr_ty, offset);
1899
1900 if (log)
1901 log->Printf("Replacing GV %s with %s", PrintValue(gv).c_str(), PrintValue(new_initializer).c_str());
1902
1903 for (GlobalVariable::use_iterator ui = gv->use_begin(), ue = gv->use_end();
1904 ui != ue;
1905 ++ui)
1906 {
1907 if (log)
1908 log->Printf("Found use %s", PrintValue(*ui).c_str());
1909
1910 ConstantExpr *const_expr = dyn_cast<ConstantExpr>(*ui);
1911 StoreInst *store_inst = dyn_cast<StoreInst>(*ui);
1912
1913 if (const_expr)
1914 {
1915 if (const_expr->getOpcode() != Instruction::GetElementPtr)
1916 {
1917 if (log)
1918 log->Printf("Use (%s) of string variable is not a GetElementPtr constant", PrintValue(const_expr).c_str());
1919
1920 return false;
1921 }
1922
1923 Constant *bit_cast = ConstantExpr::getBitCast(new_initializer, const_expr->getOperand(0)->getType());
1924 Constant *new_gep = const_expr->getWithOperandReplaced(0, bit_cast);
1925
1926 const_expr->replaceAllUsesWith(new_gep);
1927 }
1928 else if (store_inst)
1929 {
1930 Constant *bit_cast = ConstantExpr::getBitCast(new_initializer, store_inst->getValueOperand()->getType());
1931
1932 store_inst->setOperand(0, bit_cast);
1933 }
1934 else
1935 {
1936 if (log)
1937 log->Printf("Use (%s) of string variable is neither a constant nor a store", PrintValue(const_expr).c_str());
1938
1939 return false;
1940 }
1941 }
1942
1943 gv->eraseFromParent();
1944 }
1945
1946 return true;
1947 }
1948
1949 bool
ReplaceStaticLiterals(llvm::BasicBlock & basic_block)1950 IRForTarget::ReplaceStaticLiterals (llvm::BasicBlock &basic_block)
1951 {
1952 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1953
1954 typedef SmallVector <Value*, 2> ConstantList;
1955 typedef SmallVector <llvm::Instruction*, 2> UserList;
1956 typedef ConstantList::iterator ConstantIterator;
1957 typedef UserList::iterator UserIterator;
1958
1959 ConstantList static_constants;
1960 UserList static_users;
1961
1962 for (BasicBlock::iterator ii = basic_block.begin(), ie = basic_block.end();
1963 ii != ie;
1964 ++ii)
1965 {
1966 llvm::Instruction &inst = *ii;
1967
1968 for (Instruction::op_iterator oi = inst.op_begin(), oe = inst.op_end();
1969 oi != oe;
1970 ++oi)
1971 {
1972 Value *operand_val = oi->get();
1973
1974 ConstantFP *operand_constant_fp = dyn_cast<ConstantFP>(operand_val);
1975
1976 if (operand_constant_fp/* && operand_constant_fp->getType()->isX86_FP80Ty()*/)
1977 {
1978 static_constants.push_back(operand_val);
1979 static_users.push_back(ii);
1980 }
1981 }
1982 }
1983
1984 ConstantIterator constant_iter;
1985 UserIterator user_iter;
1986
1987 for (constant_iter = static_constants.begin(), user_iter = static_users.begin();
1988 constant_iter != static_constants.end();
1989 ++constant_iter, ++user_iter)
1990 {
1991 Value *operand_val = *constant_iter;
1992 llvm::Instruction *inst = *user_iter;
1993
1994 ConstantFP *operand_constant_fp = dyn_cast<ConstantFP>(operand_val);
1995
1996 if (operand_constant_fp)
1997 {
1998 Type *operand_type = operand_constant_fp->getType();
1999
2000 APFloat operand_apfloat = operand_constant_fp->getValueAPF();
2001 APInt operand_apint = operand_apfloat.bitcastToAPInt();
2002
2003 const uint8_t* operand_raw_data = (const uint8_t*)operand_apint.getRawData();
2004 size_t operand_data_size = operand_apint.getBitWidth() / 8;
2005
2006 if (log)
2007 {
2008 std::string s;
2009 raw_string_ostream ss(s);
2010 for (size_t index = 0;
2011 index < operand_data_size;
2012 ++index)
2013 {
2014 ss << (uint32_t)operand_raw_data[index];
2015 ss << " ";
2016 }
2017 ss.flush();
2018
2019 log->Printf("Found ConstantFP with size %zu and raw data %s", operand_data_size, s.c_str());
2020 }
2021
2022 lldb_private::DataBufferHeap data(operand_data_size, 0);
2023
2024 if (lldb::endian::InlHostByteOrder() != m_data_allocator.GetStream().GetByteOrder())
2025 {
2026 uint8_t *data_bytes = data.GetBytes();
2027
2028 for (size_t index = 0;
2029 index < operand_data_size;
2030 ++index)
2031 {
2032 data_bytes[index] = operand_raw_data[operand_data_size - (1 + index)];
2033 }
2034 }
2035 else
2036 {
2037 memcpy(data.GetBytes(), operand_raw_data, operand_data_size);
2038 }
2039
2040 uint64_t offset = m_data_allocator.GetStream().GetSize();
2041
2042 size_t align = m_target_data->getPrefTypeAlignment(operand_type);
2043
2044 const size_t mask = (align - 1);
2045 uint64_t aligned_offset = (offset + mask) & ~mask;
2046 m_data_allocator.GetStream().PutNHex8(aligned_offset - offset, 0);
2047 offset = aligned_offset;
2048
2049 m_data_allocator.GetStream().Write(data.GetBytes(), operand_data_size);
2050
2051 llvm::Type *fp_ptr_ty = operand_constant_fp->getType()->getPointerTo();
2052
2053 Constant *new_pointer = BuildRelocation(fp_ptr_ty, aligned_offset);
2054
2055 llvm::LoadInst *fp_load = new llvm::LoadInst(new_pointer, "fp_load", inst);
2056
2057 operand_constant_fp->replaceAllUsesWith(fp_load);
2058 }
2059 }
2060
2061 return true;
2062 }
2063
isGuardVariableRef(Value * V)2064 static bool isGuardVariableRef(Value *V)
2065 {
2066 Constant *Old = NULL;
2067
2068 if (!(Old = dyn_cast<Constant>(V)))
2069 return false;
2070
2071 ConstantExpr *CE = NULL;
2072
2073 if ((CE = dyn_cast<ConstantExpr>(V)))
2074 {
2075 if (CE->getOpcode() != Instruction::BitCast)
2076 return false;
2077
2078 Old = CE->getOperand(0);
2079 }
2080
2081 GlobalVariable *GV = dyn_cast<GlobalVariable>(Old);
2082
2083 if (!GV || !GV->hasName() || !GV->getName().startswith("_ZGV"))
2084 return false;
2085
2086 return true;
2087 }
2088
2089 void
TurnGuardLoadIntoZero(llvm::Instruction * guard_load)2090 IRForTarget::TurnGuardLoadIntoZero(llvm::Instruction* guard_load)
2091 {
2092 Constant* zero(ConstantInt::get(Type::getInt8Ty(m_module->getContext()), 0, true));
2093
2094 Value::use_iterator ui;
2095
2096 for (ui = guard_load->use_begin();
2097 ui != guard_load->use_end();
2098 ++ui)
2099 {
2100 if (isa<Constant>(*ui))
2101 {
2102 // do nothing for the moment
2103 }
2104 else
2105 {
2106 ui->replaceUsesOfWith(guard_load, zero);
2107 }
2108 }
2109
2110 guard_load->eraseFromParent();
2111 }
2112
ExciseGuardStore(Instruction * guard_store)2113 static void ExciseGuardStore(Instruction* guard_store)
2114 {
2115 guard_store->eraseFromParent();
2116 }
2117
2118 bool
RemoveGuards(BasicBlock & basic_block)2119 IRForTarget::RemoveGuards(BasicBlock &basic_block)
2120 {
2121 ///////////////////////////////////////////////////////
2122 // Eliminate any reference to guard variables found.
2123 //
2124
2125 BasicBlock::iterator ii;
2126
2127 typedef SmallVector <Instruction*, 2> InstrList;
2128 typedef InstrList::iterator InstrIterator;
2129
2130 InstrList guard_loads;
2131 InstrList guard_stores;
2132
2133 for (ii = basic_block.begin();
2134 ii != basic_block.end();
2135 ++ii)
2136 {
2137 Instruction &inst = *ii;
2138
2139 if (LoadInst *load = dyn_cast<LoadInst>(&inst))
2140 if (isGuardVariableRef(load->getPointerOperand()))
2141 guard_loads.push_back(&inst);
2142
2143 if (StoreInst *store = dyn_cast<StoreInst>(&inst))
2144 if (isGuardVariableRef(store->getPointerOperand()))
2145 guard_stores.push_back(&inst);
2146 }
2147
2148 InstrIterator iter;
2149
2150 for (iter = guard_loads.begin();
2151 iter != guard_loads.end();
2152 ++iter)
2153 TurnGuardLoadIntoZero(*iter);
2154
2155 for (iter = guard_stores.begin();
2156 iter != guard_stores.end();
2157 ++iter)
2158 ExciseGuardStore(*iter);
2159
2160 return true;
2161 }
2162
2163 // This function does not report errors; its callers are responsible.
2164 bool
UnfoldConstant(Constant * old_constant,FunctionValueCache & value_maker,FunctionValueCache & entry_instruction_finder)2165 IRForTarget::UnfoldConstant(Constant *old_constant,
2166 FunctionValueCache &value_maker,
2167 FunctionValueCache &entry_instruction_finder)
2168 {
2169 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2170
2171 Value::use_iterator ui;
2172
2173 SmallVector<User*, 16> users;
2174
2175 // We do this because the use list might change, invalidating our iterator.
2176 // Much better to keep a work list ourselves.
2177 for (ui = old_constant->use_begin();
2178 ui != old_constant->use_end();
2179 ++ui)
2180 users.push_back(*ui);
2181
2182 for (size_t i = 0;
2183 i < users.size();
2184 ++i)
2185 {
2186 User *user = users[i];
2187
2188 if (Constant *constant = dyn_cast<Constant>(user))
2189 {
2190 // synthesize a new non-constant equivalent of the constant
2191
2192 if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant))
2193 {
2194 switch (constant_expr->getOpcode())
2195 {
2196 default:
2197 if (log)
2198 log->Printf("Unhandled constant expression type: \"%s\"", PrintValue(constant_expr).c_str());
2199 return false;
2200 case Instruction::BitCast:
2201 {
2202 FunctionValueCache bit_cast_maker ([&value_maker, &entry_instruction_finder, old_constant, constant_expr] (llvm::Function *function)->llvm::Value* {
2203 // UnaryExpr
2204 // OperandList[0] is value
2205
2206 if (constant_expr->getOperand(0) != old_constant)
2207 return constant_expr;
2208
2209 return new BitCastInst(value_maker.GetValue(function),
2210 constant_expr->getType(),
2211 "",
2212 llvm::cast<Instruction>(entry_instruction_finder.GetValue(function)));
2213 });
2214
2215 if (!UnfoldConstant(constant_expr, bit_cast_maker, entry_instruction_finder))
2216 return false;
2217 }
2218 break;
2219 case Instruction::GetElementPtr:
2220 {
2221 // GetElementPtrConstantExpr
2222 // OperandList[0] is base
2223 // OperandList[1]... are indices
2224
2225 FunctionValueCache get_element_pointer_maker ([&value_maker, &entry_instruction_finder, old_constant, constant_expr] (llvm::Function *function)->llvm::Value* {
2226 Value *ptr = constant_expr->getOperand(0);
2227
2228 if (ptr == old_constant)
2229 ptr = value_maker.GetValue(function);
2230
2231 std::vector<Value*> index_vector;
2232
2233 unsigned operand_index;
2234 unsigned num_operands = constant_expr->getNumOperands();
2235
2236 for (operand_index = 1;
2237 operand_index < num_operands;
2238 ++operand_index)
2239 {
2240 Value *operand = constant_expr->getOperand(operand_index);
2241
2242 if (operand == old_constant)
2243 operand = value_maker.GetValue(function);
2244
2245 index_vector.push_back(operand);
2246 }
2247
2248 ArrayRef <Value*> indices(index_vector);
2249
2250 return GetElementPtrInst::Create(ptr, indices, "", llvm::cast<Instruction>(entry_instruction_finder.GetValue(function)));
2251 });
2252
2253 if (!UnfoldConstant(constant_expr, get_element_pointer_maker, entry_instruction_finder))
2254 return false;
2255 }
2256 break;
2257 }
2258 }
2259 else
2260 {
2261 if (log)
2262 log->Printf("Unhandled constant type: \"%s\"", PrintValue(constant).c_str());
2263 return false;
2264 }
2265 }
2266 else
2267 {
2268 if (Instruction *inst = llvm::dyn_cast<Instruction>(user))
2269 {
2270 inst->replaceUsesOfWith(old_constant, value_maker.GetValue(inst->getParent()->getParent()));
2271 }
2272 else
2273 {
2274 if (log)
2275 log->Printf("Unhandled non-constant type: \"%s\"", PrintValue(user).c_str());
2276 return false;
2277 }
2278 }
2279 }
2280
2281 if (!isa<GlobalValue>(old_constant))
2282 {
2283 old_constant->destroyConstant();
2284 }
2285
2286 return true;
2287 }
2288
2289 bool
ReplaceVariables(Function & llvm_function)2290 IRForTarget::ReplaceVariables (Function &llvm_function)
2291 {
2292 if (!m_resolve_vars)
2293 return true;
2294
2295 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2296
2297 m_decl_map->DoStructLayout();
2298
2299 if (log)
2300 log->Printf("Element arrangement:");
2301
2302 uint32_t num_elements;
2303 uint32_t element_index;
2304
2305 size_t size;
2306 off_t alignment;
2307
2308 if (!m_decl_map->GetStructInfo (num_elements, size, alignment))
2309 return false;
2310
2311 Function::arg_iterator iter(llvm_function.getArgumentList().begin());
2312
2313 if (iter == llvm_function.getArgumentList().end())
2314 {
2315 if (m_error_stream)
2316 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes no arguments (should take at least a struct pointer)");
2317
2318 return false;
2319 }
2320
2321 Argument *argument = iter;
2322
2323 if (argument->getName().equals("this"))
2324 {
2325 ++iter;
2326
2327 if (iter == llvm_function.getArgumentList().end())
2328 {
2329 if (m_error_stream)
2330 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'this' argument (should take a struct pointer too)");
2331
2332 return false;
2333 }
2334
2335 argument = iter;
2336 }
2337 else if (argument->getName().equals("self"))
2338 {
2339 ++iter;
2340
2341 if (iter == llvm_function.getArgumentList().end())
2342 {
2343 if (m_error_stream)
2344 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'self' argument (should take '_cmd' and a struct pointer too)");
2345
2346 return false;
2347 }
2348
2349 if (!iter->getName().equals("_cmd"))
2350 {
2351 if (m_error_stream)
2352 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes '%s' after 'self' argument (should take '_cmd')", iter->getName().str().c_str());
2353
2354 return false;
2355 }
2356
2357 ++iter;
2358
2359 if (iter == llvm_function.getArgumentList().end())
2360 {
2361 if (m_error_stream)
2362 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'self' and '_cmd' arguments (should take a struct pointer too)");
2363
2364 return false;
2365 }
2366
2367 argument = iter;
2368 }
2369
2370 if (!argument->getName().equals("$__lldb_arg"))
2371 {
2372 if (m_error_stream)
2373 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes an argument named '%s' instead of the struct pointer", argument->getName().str().c_str());
2374
2375 return false;
2376 }
2377
2378 if (log)
2379 log->Printf("Arg: \"%s\"", PrintValue(argument).c_str());
2380
2381 BasicBlock &entry_block(llvm_function.getEntryBlock());
2382 Instruction *FirstEntryInstruction(entry_block.getFirstNonPHIOrDbg());
2383
2384 if (!FirstEntryInstruction)
2385 {
2386 if (m_error_stream)
2387 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't find the first instruction in the wrapper for use in rewriting");
2388
2389 return false;
2390 }
2391
2392 LLVMContext &context(m_module->getContext());
2393 IntegerType *offset_type(Type::getInt32Ty(context));
2394
2395 if (!offset_type)
2396 {
2397 if (m_error_stream)
2398 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't produce an offset type");
2399
2400 return false;
2401 }
2402
2403 for (element_index = 0; element_index < num_elements; ++element_index)
2404 {
2405 const clang::NamedDecl *decl = NULL;
2406 Value *value = NULL;
2407 off_t offset;
2408 lldb_private::ConstString name;
2409
2410 if (!m_decl_map->GetStructElement (decl, value, offset, name, element_index))
2411 {
2412 if (m_error_stream)
2413 m_error_stream->Printf("Internal error [IRForTarget]: Structure information is incomplete");
2414
2415 return false;
2416 }
2417
2418 if (log)
2419 log->Printf(" \"%s\" (\"%s\") placed at %" PRId64,
2420 name.GetCString(),
2421 decl->getNameAsString().c_str(),
2422 offset);
2423
2424 if (value)
2425 {
2426 if (log)
2427 log->Printf(" Replacing [%s]", PrintValue(value).c_str());
2428
2429 FunctionValueCache body_result_maker ([this, name, offset_type, offset, argument, value] (llvm::Function *function)->llvm::Value * {
2430 // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult, in cases where the result
2431 // variable is an rvalue, we have to synthesize a dereference of the appropriate structure
2432 // entry in order to produce the static variable that the AST thinks it is accessing.
2433
2434 llvm::Instruction *entry_instruction = llvm::cast<Instruction>(m_entry_instruction_finder.GetValue(function));
2435
2436 ConstantInt *offset_int(ConstantInt::get(offset_type, offset, true));
2437 GetElementPtrInst *get_element_ptr = GetElementPtrInst::Create(argument,
2438 offset_int,
2439 "",
2440 entry_instruction);
2441
2442 if (name == m_result_name && !m_result_is_pointer)
2443 {
2444 BitCastInst *bit_cast = new BitCastInst(get_element_ptr,
2445 value->getType()->getPointerTo(),
2446 "",
2447 entry_instruction);
2448
2449 LoadInst *load = new LoadInst(bit_cast, "", entry_instruction);
2450
2451 return load;
2452 }
2453 else
2454 {
2455 BitCastInst *bit_cast = new BitCastInst(get_element_ptr, value->getType(), "", entry_instruction);
2456
2457 return bit_cast;
2458 }
2459 });
2460
2461 if (Constant *constant = dyn_cast<Constant>(value))
2462 {
2463 UnfoldConstant(constant, body_result_maker, m_entry_instruction_finder);
2464 }
2465 else if (Instruction *instruction = dyn_cast<Instruction>(value))
2466 {
2467 value->replaceAllUsesWith(body_result_maker.GetValue(instruction->getParent()->getParent()));
2468 }
2469 else
2470 {
2471 if (log)
2472 log->Printf("Unhandled non-constant type: \"%s\"", PrintValue(value).c_str());
2473 return false;
2474 }
2475
2476 if (GlobalVariable *var = dyn_cast<GlobalVariable>(value))
2477 var->eraseFromParent();
2478 }
2479 }
2480
2481 if (log)
2482 log->Printf("Total structure [align %" PRId64 ", size %zu]", alignment, size);
2483
2484 return true;
2485 }
2486
2487 llvm::Constant *
BuildRelocation(llvm::Type * type,uint64_t offset)2488 IRForTarget::BuildRelocation(llvm::Type *type, uint64_t offset)
2489 {
2490 llvm::Constant *offset_int = ConstantInt::get(m_intptr_ty, offset);
2491
2492 llvm::Constant *offset_array[1];
2493
2494 offset_array[0] = offset_int;
2495
2496 llvm::ArrayRef<llvm::Constant *> offsets(offset_array, 1);
2497
2498 llvm::Constant *reloc_getelementptr = ConstantExpr::getGetElementPtr(m_reloc_placeholder, offsets);
2499 llvm::Constant *reloc_getbitcast = ConstantExpr::getBitCast(reloc_getelementptr, type);
2500
2501 return reloc_getbitcast;
2502 }
2503
2504 bool
CompleteDataAllocation()2505 IRForTarget::CompleteDataAllocation ()
2506 {
2507 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2508
2509 if (!m_data_allocator.GetStream().GetSize())
2510 return true;
2511
2512 lldb::addr_t allocation = m_data_allocator.Allocate();
2513
2514 if (log)
2515 {
2516 if (allocation)
2517 log->Printf("Allocated static data at 0x%llx", (unsigned long long)allocation);
2518 else
2519 log->Printf("Failed to allocate static data");
2520 }
2521
2522 if (!allocation || allocation == LLDB_INVALID_ADDRESS)
2523 return false;
2524
2525 Constant *relocated_addr = ConstantInt::get(m_intptr_ty, (uint64_t)allocation);
2526 Constant *relocated_bitcast = ConstantExpr::getIntToPtr(relocated_addr, llvm::Type::getInt8PtrTy(m_module->getContext()));
2527
2528 m_reloc_placeholder->replaceAllUsesWith(relocated_bitcast);
2529
2530 m_reloc_placeholder->eraseFromParent();
2531
2532 return true;
2533 }
2534
2535 bool
StripAllGVs(Module & llvm_module)2536 IRForTarget::StripAllGVs (Module &llvm_module)
2537 {
2538 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2539 std::vector<GlobalVariable *> global_vars;
2540 std::set<GlobalVariable *>erased_vars;
2541
2542 bool erased = true;
2543
2544 while (erased)
2545 {
2546 erased = false;
2547
2548 for (Module::global_iterator gi = llvm_module.global_begin(), ge = llvm_module.global_end();
2549 gi != ge;
2550 ++gi)
2551 {
2552 GlobalVariable *global_var = dyn_cast<GlobalVariable>(gi);
2553
2554 global_var->removeDeadConstantUsers();
2555
2556 if (global_var->use_empty())
2557 {
2558 if (log)
2559 log->Printf("Did remove %s",
2560 PrintValue(global_var).c_str());
2561 global_var->eraseFromParent();
2562 erased = true;
2563 break;
2564 }
2565 }
2566 }
2567
2568 for (Module::global_iterator gi = llvm_module.global_begin(), ge = llvm_module.global_end();
2569 gi != ge;
2570 ++gi)
2571 {
2572 GlobalVariable *global_var = dyn_cast<GlobalVariable>(gi);
2573
2574 GlobalValue::use_iterator ui = global_var->use_begin();
2575
2576 if (log)
2577 log->Printf("Couldn't remove %s because of %s",
2578 PrintValue(global_var).c_str(),
2579 PrintValue(*ui).c_str());
2580 }
2581
2582 return true;
2583 }
2584
2585 bool
runOnModule(Module & llvm_module)2586 IRForTarget::runOnModule (Module &llvm_module)
2587 {
2588 lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2589
2590 m_module = &llvm_module;
2591 m_target_data.reset(new DataLayout(m_module));
2592 m_intptr_ty = llvm::Type::getIntNTy(m_module->getContext(), m_target_data->getPointerSizeInBits());
2593
2594 if (log)
2595 {
2596 std::string s;
2597 raw_string_ostream oss(s);
2598
2599 m_module->print(oss, NULL);
2600
2601 oss.flush();
2602
2603 log->Printf("Module as passed in to IRForTarget: \n\"%s\"", s.c_str());
2604 }
2605
2606 Function* main_function = m_module->getFunction(StringRef(m_func_name.c_str()));
2607
2608 if (!main_function)
2609 {
2610 if (log)
2611 log->Printf("Couldn't find \"%s()\" in the module", m_func_name.c_str());
2612
2613 if (m_error_stream)
2614 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't find wrapper '%s' in the module", m_func_name.c_str());
2615
2616 return false;
2617 }
2618
2619 if (!FixFunctionLinkage (*main_function))
2620 {
2621 if (log)
2622 log->Printf("Couldn't fix the linkage for the function");
2623
2624 return false;
2625 }
2626
2627 llvm::Type *int8_ty = Type::getInt8Ty(m_module->getContext());
2628
2629 m_reloc_placeholder = new llvm::GlobalVariable((*m_module),
2630 int8_ty,
2631 false /* IsConstant */,
2632 GlobalVariable::InternalLinkage,
2633 Constant::getNullValue(int8_ty),
2634 "reloc_placeholder",
2635 NULL /* InsertBefore */,
2636 GlobalVariable::NotThreadLocal /* ThreadLocal */,
2637 0 /* AddressSpace */);
2638
2639 ////////////////////////////////////////////////////////////
2640 // Replace $__lldb_expr_result with a persistent variable
2641 //
2642
2643 if (!CreateResultVariable(*main_function))
2644 {
2645 if (log)
2646 log->Printf("CreateResultVariable() failed");
2647
2648 // CreateResultVariable() reports its own errors, so we don't do so here
2649
2650 return false;
2651 }
2652
2653 if (log && log->GetVerbose())
2654 {
2655 std::string s;
2656 raw_string_ostream oss(s);
2657
2658 m_module->print(oss, NULL);
2659
2660 oss.flush();
2661
2662 log->Printf("Module after creating the result variable: \n\"%s\"", s.c_str());
2663 }
2664
2665 for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2666 fi != fe;
2667 ++fi)
2668 {
2669 llvm::Function *function = fi;
2670
2671 if (function->begin() == function->end())
2672 continue;
2673
2674 Function::iterator bbi;
2675
2676 for (bbi = function->begin();
2677 bbi != function->end();
2678 ++bbi)
2679 {
2680 if (!RemoveGuards(*bbi))
2681 {
2682 if (log)
2683 log->Printf("RemoveGuards() failed");
2684
2685 // RemoveGuards() reports its own errors, so we don't do so here
2686
2687 return false;
2688 }
2689
2690 if (!RewritePersistentAllocs(*bbi))
2691 {
2692 if (log)
2693 log->Printf("RewritePersistentAllocs() failed");
2694
2695 // RewritePersistentAllocs() reports its own errors, so we don't do so here
2696
2697 return false;
2698 }
2699
2700 if (!RemoveCXAAtExit(*bbi))
2701 {
2702 if (log)
2703 log->Printf("RemoveCXAAtExit() failed");
2704
2705 // RemoveCXAAtExit() reports its own errors, so we don't do so here
2706
2707 return false;
2708 }
2709 }
2710 }
2711
2712 ///////////////////////////////////////////////////////////////////////////////
2713 // Fix all Objective-C constant strings to use NSStringWithCString:encoding:
2714 //
2715
2716 if (!RewriteObjCConstStrings())
2717 {
2718 if (log)
2719 log->Printf("RewriteObjCConstStrings() failed");
2720
2721 // RewriteObjCConstStrings() reports its own errors, so we don't do so here
2722
2723 return false;
2724 }
2725
2726 ///////////////////////////////
2727 // Resolve function pointers
2728 //
2729
2730 if (!ResolveFunctionPointers(llvm_module))
2731 {
2732 if (log)
2733 log->Printf("ResolveFunctionPointers() failed");
2734
2735 // ResolveFunctionPointers() reports its own errors, so we don't do so here
2736
2737 return false;
2738 }
2739
2740 for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2741 fi != fe;
2742 ++fi)
2743 {
2744 llvm::Function *function = fi;
2745
2746 for (llvm::Function::iterator bbi = function->begin(), bbe = function->end();
2747 bbi != bbe;
2748 ++bbi)
2749 {
2750 if (!RewriteObjCSelectors(*bbi))
2751 {
2752 if (log)
2753 log->Printf("RewriteObjCSelectors() failed");
2754
2755 // RewriteObjCSelectors() reports its own errors, so we don't do so here
2756
2757 return false;
2758 }
2759 }
2760 }
2761
2762 for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2763 fi != fe;
2764 ++fi)
2765 {
2766 llvm::Function *function = fi;
2767
2768 for (llvm::Function::iterator bbi = function->begin(), bbe = function->end();
2769 bbi != bbe;
2770 ++bbi)
2771 {
2772 if (!ResolveCalls(*bbi))
2773 {
2774 if (log)
2775 log->Printf("ResolveCalls() failed");
2776
2777 // ResolveCalls() reports its own errors, so we don't do so here
2778
2779 return false;
2780 }
2781
2782 if (!ReplaceStaticLiterals(*bbi))
2783 {
2784 if (log)
2785 log->Printf("ReplaceStaticLiterals() failed");
2786
2787 return false;
2788 }
2789 }
2790 }
2791
2792 ////////////////////////////////////////////////////////////////////////
2793 // Run function-level passes that only make sense on the main function
2794 //
2795
2796 if (!ResolveExternals(*main_function))
2797 {
2798 if (log)
2799 log->Printf("ResolveExternals() failed");
2800
2801 // ResolveExternals() reports its own errors, so we don't do so here
2802
2803 return false;
2804 }
2805
2806 if (!ReplaceVariables(*main_function))
2807 {
2808 if (log)
2809 log->Printf("ReplaceVariables() failed");
2810
2811 // ReplaceVariables() reports its own errors, so we don't do so here
2812
2813 return false;
2814 }
2815
2816 if (!ReplaceStrings())
2817 {
2818 if (log)
2819 log->Printf("ReplaceStrings() failed");
2820
2821 return false;
2822 }
2823
2824 if (!CompleteDataAllocation())
2825 {
2826 if (log)
2827 log->Printf("CompleteDataAllocation() failed");
2828
2829 return false;
2830 }
2831
2832 if (!StripAllGVs(llvm_module))
2833 {
2834 if (log)
2835 log->Printf("StripAllGVs() failed");
2836 }
2837
2838 if (log && log->GetVerbose())
2839 {
2840 std::string s;
2841 raw_string_ostream oss(s);
2842
2843 m_module->print(oss, NULL);
2844
2845 oss.flush();
2846
2847 log->Printf("Module after preparing for execution: \n\"%s\"", s.c_str());
2848 }
2849
2850 return true;
2851 }
2852
2853 void
assignPassManager(PMStack & pass_mgr_stack,PassManagerType pass_mgr_type)2854 IRForTarget::assignPassManager (PMStack &pass_mgr_stack, PassManagerType pass_mgr_type)
2855 {
2856 }
2857
2858 PassManagerType
getPotentialPassManagerType() const2859 IRForTarget::getPotentialPassManagerType() const
2860 {
2861 return PMT_ModulePassManager;
2862 }
2863