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