1 //===-- IRForTarget.cpp -----------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "IRForTarget.h"
10
11 #include "ClangExpressionDeclMap.h"
12
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/LegacyPassManager.h"
19 #include "llvm/IR/Metadata.h"
20 #include "llvm/IR/Module.h"
21 #include "llvm/IR/ValueSymbolTable.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include "llvm/Transforms/IPO.h"
24
25 #include "clang/AST/ASTContext.h"
26
27 #include "lldb/Core/dwarf.h"
28 #include "lldb/Expression/IRExecutionUnit.h"
29 #include "lldb/Expression/IRInterpreter.h"
30 #include "lldb/Symbol/ClangASTContext.h"
31 #include "lldb/Symbol/ClangUtil.h"
32 #include "lldb/Symbol/CompilerType.h"
33 #include "lldb/Utility/ConstString.h"
34 #include "lldb/Utility/DataBufferHeap.h"
35 #include "lldb/Utility/Endian.h"
36 #include "lldb/Utility/Log.h"
37 #include "lldb/Utility/Scalar.h"
38 #include "lldb/Utility/StreamString.h"
39
40 #include <map>
41
42 using namespace llvm;
43
44 static char ID;
45
46 typedef SmallVector<Instruction *, 2> InstrList;
47
FunctionValueCache(Maker const & maker)48 IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
49 : m_maker(maker), m_values() {}
50
~FunctionValueCache()51 IRForTarget::FunctionValueCache::~FunctionValueCache() {}
52
53 llvm::Value *
GetValue(llvm::Function * function)54 IRForTarget::FunctionValueCache::GetValue(llvm::Function *function) {
55 if (!m_values.count(function)) {
56 llvm::Value *ret = m_maker(function);
57 m_values[function] = ret;
58 return ret;
59 }
60 return m_values[function];
61 }
62
FindEntryInstruction(llvm::Function * function)63 static llvm::Value *FindEntryInstruction(llvm::Function *function) {
64 if (function->empty())
65 return nullptr;
66
67 return function->getEntryBlock().getFirstNonPHIOrDbg();
68 }
69
IRForTarget(lldb_private::ClangExpressionDeclMap * decl_map,bool resolve_vars,lldb_private::IRExecutionUnit & execution_unit,lldb_private::Stream & error_stream,const char * func_name)70 IRForTarget::IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map,
71 bool resolve_vars,
72 lldb_private::IRExecutionUnit &execution_unit,
73 lldb_private::Stream &error_stream,
74 const char *func_name)
75 : ModulePass(ID), m_resolve_vars(resolve_vars), m_func_name(func_name),
76 m_module(nullptr), m_decl_map(decl_map),
77 m_CFStringCreateWithBytes(nullptr), m_sel_registerName(nullptr),
78 m_objc_getClass(nullptr), m_intptr_ty(nullptr),
79 m_error_stream(error_stream), m_execution_unit(execution_unit),
80 m_result_store(nullptr), m_result_is_pointer(false),
81 m_reloc_placeholder(nullptr),
82 m_entry_instruction_finder(FindEntryInstruction) {}
83
84 /* Handy utility functions used at several places in the code */
85
PrintValue(const Value * value,bool truncate=false)86 static std::string PrintValue(const Value *value, bool truncate = false) {
87 std::string s;
88 if (value) {
89 raw_string_ostream rso(s);
90 value->print(rso);
91 rso.flush();
92 if (truncate)
93 s.resize(s.length() - 1);
94 }
95 return s;
96 }
97
PrintType(const llvm::Type * type,bool truncate=false)98 static std::string PrintType(const llvm::Type *type, bool truncate = false) {
99 std::string s;
100 raw_string_ostream rso(s);
101 type->print(rso);
102 rso.flush();
103 if (truncate)
104 s.resize(s.length() - 1);
105 return s;
106 }
107
~IRForTarget()108 IRForTarget::~IRForTarget() {}
109
FixFunctionLinkage(llvm::Function & llvm_function)110 bool IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function) {
111 llvm_function.setLinkage(GlobalValue::ExternalLinkage);
112
113 return true;
114 }
115
DeclForGlobal(const GlobalValue * global_val,Module * module)116 clang::NamedDecl *IRForTarget::DeclForGlobal(const GlobalValue *global_val,
117 Module *module) {
118 NamedMDNode *named_metadata =
119 module->getNamedMetadata("clang.global.decl.ptrs");
120
121 if (!named_metadata)
122 return nullptr;
123
124 unsigned num_nodes = named_metadata->getNumOperands();
125 unsigned node_index;
126
127 for (node_index = 0; node_index < num_nodes; ++node_index) {
128 llvm::MDNode *metadata_node =
129 dyn_cast<llvm::MDNode>(named_metadata->getOperand(node_index));
130 if (!metadata_node)
131 return nullptr;
132
133 if (metadata_node->getNumOperands() != 2)
134 continue;
135
136 if (mdconst::dyn_extract_or_null<GlobalValue>(
137 metadata_node->getOperand(0)) != global_val)
138 continue;
139
140 ConstantInt *constant_int =
141 mdconst::dyn_extract<ConstantInt>(metadata_node->getOperand(1));
142
143 if (!constant_int)
144 return nullptr;
145
146 uintptr_t ptr = constant_int->getZExtValue();
147
148 return reinterpret_cast<clang::NamedDecl *>(ptr);
149 }
150
151 return nullptr;
152 }
153
DeclForGlobal(GlobalValue * global_val)154 clang::NamedDecl *IRForTarget::DeclForGlobal(GlobalValue *global_val) {
155 return DeclForGlobal(global_val, m_module);
156 }
157
158 /// Returns true iff the mangled symbol is for a static guard variable.
isGuardVariableSymbol(llvm::StringRef mangled_symbol,bool check_ms_abi=true)159 static bool isGuardVariableSymbol(llvm::StringRef mangled_symbol,
160 bool check_ms_abi = true) {
161 bool result = mangled_symbol.startswith("_ZGV"); // Itanium ABI guard variable
162 if (check_ms_abi)
163 result |= mangled_symbol.endswith("@4IA"); // Microsoft ABI
164 return result;
165 }
166
CreateResultVariable(llvm::Function & llvm_function)167 bool IRForTarget::CreateResultVariable(llvm::Function &llvm_function) {
168 lldb_private::Log *log(
169 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
170
171 if (!m_resolve_vars)
172 return true;
173
174 // Find the result variable. If it doesn't exist, we can give up right here.
175
176 ValueSymbolTable &value_symbol_table = m_module->getValueSymbolTable();
177
178 llvm::StringRef result_name;
179 bool found_result = false;
180
181 for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
182 result_name = value_symbol.first();
183
184 // Check if this is a guard variable. It seems this causes some hiccups
185 // on Windows, so let's only check for Itanium guard variables.
186 bool is_guard_var = isGuardVariableSymbol(result_name, /*MS ABI*/ false);
187
188 if (result_name.contains("$__lldb_expr_result_ptr") && !is_guard_var) {
189 found_result = true;
190 m_result_is_pointer = true;
191 break;
192 }
193
194 if (result_name.contains("$__lldb_expr_result") && !is_guard_var) {
195 found_result = true;
196 m_result_is_pointer = false;
197 break;
198 }
199 }
200
201 if (!found_result) {
202 LLDB_LOG(log, "Couldn't find result variable");
203
204 return true;
205 }
206
207 LLDB_LOG(log, "Result name: \"{0}\"", result_name);
208
209 Value *result_value = m_module->getNamedValue(result_name);
210
211 if (!result_value) {
212 LLDB_LOG(log, "Result variable had no data");
213
214 m_error_stream.Format("Internal error [IRForTarget]: Result variable's "
215 "name ({0}) exists, but not its definition\n",
216 result_name);
217
218 return false;
219 }
220
221 LLDB_LOG(log, "Found result in the IR: \"{0}\"",
222 PrintValue(result_value, false));
223
224 GlobalVariable *result_global = dyn_cast<GlobalVariable>(result_value);
225
226 if (!result_global) {
227 LLDB_LOG(log, "Result variable isn't a GlobalVariable");
228
229 m_error_stream.Format("Internal error [IRForTarget]: Result variable ({0}) "
230 "is defined, but is not a global variable\n",
231 result_name);
232
233 return false;
234 }
235
236 clang::NamedDecl *result_decl = DeclForGlobal(result_global);
237 if (!result_decl) {
238 LLDB_LOG(log, "Result variable doesn't have a corresponding Decl");
239
240 m_error_stream.Format("Internal error [IRForTarget]: Result variable ({0}) "
241 "does not have a corresponding Clang entity\n",
242 result_name);
243
244 return false;
245 }
246
247 if (log) {
248 std::string decl_desc_str;
249 raw_string_ostream decl_desc_stream(decl_desc_str);
250 result_decl->print(decl_desc_stream);
251 decl_desc_stream.flush();
252
253 LLDB_LOG(log, "Found result decl: \"{0}\"", decl_desc_str);
254 }
255
256 clang::VarDecl *result_var = dyn_cast<clang::VarDecl>(result_decl);
257 if (!result_var) {
258 LLDB_LOG(log, "Result variable Decl isn't a VarDecl");
259
260 m_error_stream.Format("Internal error [IRForTarget]: Result variable "
261 "({0})'s corresponding Clang entity isn't a "
262 "variable\n",
263 result_name);
264
265 return false;
266 }
267
268 // Get the next available result name from m_decl_map and create the
269 // persistent variable for it
270
271 // If the result is an Lvalue, it is emitted as a pointer; see
272 // ASTResultSynthesizer::SynthesizeBodyResult.
273 if (m_result_is_pointer) {
274 clang::QualType pointer_qual_type = result_var->getType();
275 const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
276
277 const clang::PointerType *pointer_pointertype =
278 pointer_type->getAs<clang::PointerType>();
279 const clang::ObjCObjectPointerType *pointer_objcobjpointertype =
280 pointer_type->getAs<clang::ObjCObjectPointerType>();
281
282 if (pointer_pointertype) {
283 clang::QualType element_qual_type = pointer_pointertype->getPointeeType();
284
285 m_result_type = lldb_private::TypeFromParser(
286 element_qual_type.getAsOpaquePtr(),
287 lldb_private::ClangASTContext::GetASTContext(
288 &result_decl->getASTContext()));
289 } else if (pointer_objcobjpointertype) {
290 clang::QualType element_qual_type =
291 clang::QualType(pointer_objcobjpointertype->getObjectType(), 0);
292
293 m_result_type = lldb_private::TypeFromParser(
294 element_qual_type.getAsOpaquePtr(),
295 lldb_private::ClangASTContext::GetASTContext(
296 &result_decl->getASTContext()));
297 } else {
298 LLDB_LOG(log, "Expected result to have pointer type, but it did not");
299
300 m_error_stream.Format("Internal error [IRForTarget]: Lvalue result ({0}) "
301 "is not a pointer variable\n",
302 result_name);
303
304 return false;
305 }
306 } else {
307 m_result_type = lldb_private::TypeFromParser(
308 result_var->getType().getAsOpaquePtr(),
309 lldb_private::ClangASTContext::GetASTContext(
310 &result_decl->getASTContext()));
311 }
312
313 lldb::TargetSP target_sp(m_execution_unit.GetTarget());
314 lldb_private::ExecutionContext exe_ctx(target_sp, true);
315 llvm::Optional<uint64_t> bit_size =
316 m_result_type.GetBitSize(exe_ctx.GetBestExecutionContextScope());
317 if (!bit_size) {
318 lldb_private::StreamString type_desc_stream;
319 m_result_type.DumpTypeDescription(&type_desc_stream);
320
321 LLDB_LOG(log, "Result type has unknown size");
322
323 m_error_stream.Printf("Error [IRForTarget]: Size of result type '%s' "
324 "couldn't be determined\n",
325 type_desc_stream.GetData());
326 return false;
327 }
328
329 if (log) {
330 lldb_private::StreamString type_desc_stream;
331 m_result_type.DumpTypeDescription(&type_desc_stream);
332
333 LLDB_LOG(log, "Result decl type: \"{0}\"", type_desc_stream.GetData());
334 }
335
336 m_result_name = lldb_private::ConstString("$RESULT_NAME");
337
338 LLDB_LOG(log, "Creating a new result global: \"{0}\" with size {1}",
339 m_result_name, m_result_type.GetByteSize(nullptr).getValueOr(0));
340
341 // Construct a new result global and set up its metadata
342
343 GlobalVariable *new_result_global = new GlobalVariable(
344 (*m_module), result_global->getType()->getElementType(),
345 false, /* not constant */
346 GlobalValue::ExternalLinkage, nullptr, /* no initializer */
347 m_result_name.GetCString());
348
349 // It's too late in compilation to create a new VarDecl for this, but we
350 // don't need to. We point the metadata at the old VarDecl. This creates an
351 // odd anomaly: a variable with a Value whose name is something like $0 and a
352 // Decl whose name is $__lldb_expr_result. This condition is handled in
353 // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
354 // fixed up.
355
356 ConstantInt *new_constant_int =
357 ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
358 reinterpret_cast<uintptr_t>(result_decl), false);
359
360 llvm::Metadata *values[2];
361 values[0] = ConstantAsMetadata::get(new_result_global);
362 values[1] = ConstantAsMetadata::get(new_constant_int);
363
364 ArrayRef<Metadata *> value_ref(values, 2);
365
366 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
367 NamedMDNode *named_metadata =
368 m_module->getNamedMetadata("clang.global.decl.ptrs");
369 named_metadata->addOperand(persistent_global_md);
370
371 LLDB_LOG(log, "Replacing \"{0}\" with \"{1}\"", PrintValue(result_global),
372 PrintValue(new_result_global));
373
374 if (result_global->use_empty()) {
375 // We need to synthesize a store for this variable, because otherwise
376 // there's nothing to put into its equivalent persistent variable.
377
378 BasicBlock &entry_block(llvm_function.getEntryBlock());
379 Instruction *first_entry_instruction(entry_block.getFirstNonPHIOrDbg());
380
381 if (!first_entry_instruction)
382 return false;
383
384 if (!result_global->hasInitializer()) {
385 LLDB_LOG(log, "Couldn't find initializer for unused variable");
386
387 m_error_stream.Format("Internal error [IRForTarget]: Result variable "
388 "({0}) has no writes and no initializer\n",
389 result_name);
390
391 return false;
392 }
393
394 Constant *initializer = result_global->getInitializer();
395
396 StoreInst *synthesized_store =
397 new StoreInst(initializer, new_result_global, first_entry_instruction);
398
399 LLDB_LOG(log, "Synthesized result store \"{0}\"\n",
400 PrintValue(synthesized_store));
401 } else {
402 result_global->replaceAllUsesWith(new_result_global);
403 }
404
405 if (!m_decl_map->AddPersistentVariable(
406 result_decl, m_result_name, m_result_type, true, m_result_is_pointer))
407 return false;
408
409 result_global->eraseFromParent();
410
411 return true;
412 }
413
RewriteObjCConstString(llvm::GlobalVariable * ns_str,llvm::GlobalVariable * cstr)414 bool IRForTarget::RewriteObjCConstString(llvm::GlobalVariable *ns_str,
415 llvm::GlobalVariable *cstr) {
416 lldb_private::Log *log(
417 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
418
419 Type *ns_str_ty = ns_str->getType();
420
421 Type *i8_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
422 Type *i32_ty = Type::getInt32Ty(m_module->getContext());
423 Type *i8_ty = Type::getInt8Ty(m_module->getContext());
424
425 if (!m_CFStringCreateWithBytes) {
426 lldb::addr_t CFStringCreateWithBytes_addr;
427
428 static lldb_private::ConstString g_CFStringCreateWithBytes_str(
429 "CFStringCreateWithBytes");
430
431 bool missing_weak = false;
432 CFStringCreateWithBytes_addr =
433 m_execution_unit.FindSymbol(g_CFStringCreateWithBytes_str,
434 missing_weak);
435 if (CFStringCreateWithBytes_addr == LLDB_INVALID_ADDRESS || missing_weak) {
436 log->PutCString("Couldn't find CFStringCreateWithBytes in the target");
437
438 m_error_stream.Printf("Error [IRForTarget]: Rewriting an Objective-C "
439 "constant string requires "
440 "CFStringCreateWithBytes\n");
441
442 return false;
443 }
444
445 LLDB_LOG(log, "Found CFStringCreateWithBytes at {0}",
446 CFStringCreateWithBytes_addr);
447
448 // Build the function type:
449 //
450 // CFStringRef CFStringCreateWithBytes (
451 // CFAllocatorRef alloc,
452 // const UInt8 *bytes,
453 // CFIndex numBytes,
454 // CFStringEncoding encoding,
455 // Boolean isExternalRepresentation
456 // );
457 //
458 // We make the following substitutions:
459 //
460 // CFStringRef -> i8*
461 // CFAllocatorRef -> i8*
462 // UInt8 * -> i8*
463 // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its
464 // pointer size for now) CFStringEncoding -> i32 Boolean -> i8
465
466 Type *arg_type_array[5];
467
468 arg_type_array[0] = i8_ptr_ty;
469 arg_type_array[1] = i8_ptr_ty;
470 arg_type_array[2] = m_intptr_ty;
471 arg_type_array[3] = i32_ty;
472 arg_type_array[4] = i8_ty;
473
474 ArrayRef<Type *> CFSCWB_arg_types(arg_type_array, 5);
475
476 llvm::FunctionType *CFSCWB_ty =
477 FunctionType::get(ns_str_ty, CFSCWB_arg_types, false);
478
479 // Build the constant containing the pointer to the function
480 PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
481 Constant *CFSCWB_addr_int =
482 ConstantInt::get(m_intptr_ty, CFStringCreateWithBytes_addr, false);
483 m_CFStringCreateWithBytes = {
484 CFSCWB_ty, ConstantExpr::getIntToPtr(CFSCWB_addr_int, CFSCWB_ptr_ty)};
485 }
486
487 ConstantDataSequential *string_array = nullptr;
488
489 if (cstr)
490 string_array = dyn_cast<ConstantDataSequential>(cstr->getInitializer());
491
492 Constant *alloc_arg = Constant::getNullValue(i8_ptr_ty);
493 Constant *bytes_arg = cstr ? ConstantExpr::getBitCast(cstr, i8_ptr_ty)
494 : Constant::getNullValue(i8_ptr_ty);
495 Constant *numBytes_arg = ConstantInt::get(
496 m_intptr_ty, cstr ? (string_array->getNumElements() - 1) * string_array->getElementByteSize() : 0, false);
497 int encoding_flags = 0;
498 switch (cstr ? string_array->getElementByteSize() : 1) {
499 case 1:
500 encoding_flags = 0x08000100; /* 0x08000100 is kCFStringEncodingUTF8 */
501 break;
502 case 2:
503 encoding_flags = 0x0100; /* 0x0100 is kCFStringEncodingUTF16 */
504 break;
505 case 4:
506 encoding_flags = 0x0c000100; /* 0x0c000100 is kCFStringEncodingUTF32 */
507 break;
508 default:
509 encoding_flags = 0x0600; /* fall back to 0x0600, kCFStringEncodingASCII */
510 LLDB_LOG(log, "Encountered an Objective-C constant string with unusual "
511 "element size {0}",
512 string_array->getElementByteSize());
513 }
514 Constant *encoding_arg = ConstantInt::get(i32_ty, encoding_flags, false);
515 Constant *isExternal_arg =
516 ConstantInt::get(i8_ty, 0x0, false); /* 0x0 is false */
517
518 Value *argument_array[5];
519
520 argument_array[0] = alloc_arg;
521 argument_array[1] = bytes_arg;
522 argument_array[2] = numBytes_arg;
523 argument_array[3] = encoding_arg;
524 argument_array[4] = isExternal_arg;
525
526 ArrayRef<Value *> CFSCWB_arguments(argument_array, 5);
527
528 FunctionValueCache CFSCWB_Caller(
529 [this, &CFSCWB_arguments](llvm::Function *function) -> llvm::Value * {
530 return CallInst::Create(
531 m_CFStringCreateWithBytes, CFSCWB_arguments,
532 "CFStringCreateWithBytes",
533 llvm::cast<Instruction>(
534 m_entry_instruction_finder.GetValue(function)));
535 });
536
537 if (!UnfoldConstant(ns_str, nullptr, CFSCWB_Caller, m_entry_instruction_finder,
538 m_error_stream)) {
539 LLDB_LOG(log, "Couldn't replace the NSString with the result of the call");
540
541 m_error_stream.Printf("error [IRForTarget internal]: Couldn't replace an "
542 "Objective-C constant string with a dynamic "
543 "string\n");
544
545 return false;
546 }
547
548 ns_str->eraseFromParent();
549
550 return true;
551 }
552
RewriteObjCConstStrings()553 bool IRForTarget::RewriteObjCConstStrings() {
554 lldb_private::Log *log(
555 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
556
557 ValueSymbolTable &value_symbol_table = m_module->getValueSymbolTable();
558
559 for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
560 llvm::StringRef value_name = value_symbol.first();
561
562 if (value_name.contains("_unnamed_cfstring_")) {
563 Value *nsstring_value = value_symbol.second;
564
565 GlobalVariable *nsstring_global =
566 dyn_cast<GlobalVariable>(nsstring_value);
567
568 if (!nsstring_global) {
569 LLDB_LOG(log, "NSString variable is not a GlobalVariable");
570
571 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
572 "constant string is not a global variable\n");
573
574 return false;
575 }
576
577 if (!nsstring_global->hasInitializer()) {
578 LLDB_LOG(log, "NSString variable does not have an initializer");
579
580 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
581 "constant string does not have an initializer\n");
582
583 return false;
584 }
585
586 ConstantStruct *nsstring_struct =
587 dyn_cast<ConstantStruct>(nsstring_global->getInitializer());
588
589 if (!nsstring_struct) {
590 LLDB_LOG(log,
591 "NSString variable's initializer is not a ConstantStruct");
592
593 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
594 "constant string is not a structure constant\n");
595
596 return false;
597 }
598
599 // We expect the following structure:
600 //
601 // struct {
602 // int *isa;
603 // int flags;
604 // char *str;
605 // long length;
606 // };
607
608 if (nsstring_struct->getNumOperands() != 4) {
609
610 LLDB_LOG(log,
611 "NSString variable's initializer structure has an "
612 "unexpected number of members. Should be 4, is {0}",
613 nsstring_struct->getNumOperands());
614
615 m_error_stream.Printf("Internal error [IRForTarget]: The struct for an "
616 "Objective-C constant string is not as "
617 "expected\n");
618
619 return false;
620 }
621
622 Constant *nsstring_member = nsstring_struct->getOperand(2);
623
624 if (!nsstring_member) {
625 LLDB_LOG(log, "NSString initializer's str element was empty");
626
627 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
628 "constant string does not have a string "
629 "initializer\n");
630
631 return false;
632 }
633
634 ConstantExpr *nsstring_expr = dyn_cast<ConstantExpr>(nsstring_member);
635
636 if (!nsstring_expr) {
637 LLDB_LOG(log,
638 "NSString initializer's str element is not a ConstantExpr");
639
640 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
641 "constant string's string initializer is not "
642 "constant\n");
643
644 return false;
645 }
646
647 GlobalVariable *cstr_global = nullptr;
648
649 if (nsstring_expr->getOpcode() == Instruction::GetElementPtr) {
650 Constant *nsstring_cstr = nsstring_expr->getOperand(0);
651 cstr_global = dyn_cast<GlobalVariable>(nsstring_cstr);
652 } else if (nsstring_expr->getOpcode() == Instruction::BitCast) {
653 Constant *nsstring_cstr = nsstring_expr->getOperand(0);
654 cstr_global = dyn_cast<GlobalVariable>(nsstring_cstr);
655 }
656
657 if (!cstr_global) {
658 LLDB_LOG(log,
659 "NSString initializer's str element is not a GlobalVariable");
660
661 m_error_stream.Printf("Internal error [IRForTarget]: Unhandled"
662 "constant string initializer\n");
663
664 return false;
665 }
666
667 if (!cstr_global->hasInitializer()) {
668 LLDB_LOG(log, "NSString initializer's str element does not have an "
669 "initializer");
670
671 m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
672 "constant string's string initializer doesn't "
673 "point to initialized data\n");
674
675 return false;
676 }
677
678 /*
679 if (!cstr_array)
680 {
681 if (log)
682 log->PutCString("NSString initializer's str element is not a
683 ConstantArray");
684
685 if (m_error_stream)
686 m_error_stream.Printf("Internal error [IRForTarget]: An
687 Objective-C constant string's string initializer doesn't point to an
688 array\n");
689
690 return false;
691 }
692
693 if (!cstr_array->isCString())
694 {
695 if (log)
696 log->PutCString("NSString initializer's str element is not a C
697 string array");
698
699 if (m_error_stream)
700 m_error_stream.Printf("Internal error [IRForTarget]: An
701 Objective-C constant string's string initializer doesn't point to a C
702 string\n");
703
704 return false;
705 }
706 */
707
708 ConstantDataArray *cstr_array =
709 dyn_cast<ConstantDataArray>(cstr_global->getInitializer());
710
711 if (cstr_array)
712 LLDB_LOG(log, "Found NSString constant {0}, which contains \"{1}\"",
713 value_name, cstr_array->getAsString());
714 else
715 LLDB_LOG(log, "Found NSString constant {0}, which contains \"\"",
716 value_name);
717
718 if (!cstr_array)
719 cstr_global = nullptr;
720
721 if (!RewriteObjCConstString(nsstring_global, cstr_global)) {
722 LLDB_LOG(log, "Error rewriting the constant string");
723
724 // We don't print an error message here because RewriteObjCConstString
725 // has done so for us.
726
727 return false;
728 }
729 }
730 }
731
732 for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
733 llvm::StringRef value_name = value_symbol.first();
734
735 if (value_name == "__CFConstantStringClassReference") {
736 GlobalVariable *gv = dyn_cast<GlobalVariable>(value_symbol.second);
737
738 if (!gv) {
739 LLDB_LOG(log,
740 "__CFConstantStringClassReference is not a global variable");
741
742 m_error_stream.Printf("Internal error [IRForTarget]: Found a "
743 "CFConstantStringClassReference, but it is not a "
744 "global object\n");
745
746 return false;
747 }
748
749 gv->eraseFromParent();
750
751 break;
752 }
753 }
754
755 return true;
756 }
757
IsObjCSelectorRef(Value * value)758 static bool IsObjCSelectorRef(Value *value) {
759 GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
760
761 return !(!global_variable || !global_variable->hasName() ||
762 !global_variable->getName().startswith("OBJC_SELECTOR_REFERENCES_"));
763 }
764
765 // This function does not report errors; its callers are responsible.
RewriteObjCSelector(Instruction * selector_load)766 bool IRForTarget::RewriteObjCSelector(Instruction *selector_load) {
767 lldb_private::Log *log(
768 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
769
770 LoadInst *load = dyn_cast<LoadInst>(selector_load);
771
772 if (!load)
773 return false;
774
775 // Unpack the message name from the selector. In LLVM IR, an objc_msgSend
776 // gets represented as
777 //
778 // %tmp = load i8** @"OBJC_SELECTOR_REFERENCES_" ; <i8*> %call = call
779 // i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...) ; <i8*>
780 //
781 // where %obj is the object pointer and %tmp is the selector.
782 //
783 // @"OBJC_SELECTOR_REFERENCES_" is a pointer to a character array called
784 // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_".
785 // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_" contains the string.
786
787 // Find the pointer's initializer (a ConstantExpr with opcode GetElementPtr)
788 // and get the string from its target
789
790 GlobalVariable *_objc_selector_references_ =
791 dyn_cast<GlobalVariable>(load->getPointerOperand());
792
793 if (!_objc_selector_references_ ||
794 !_objc_selector_references_->hasInitializer())
795 return false;
796
797 Constant *osr_initializer = _objc_selector_references_->getInitializer();
798
799 ConstantExpr *osr_initializer_expr = dyn_cast<ConstantExpr>(osr_initializer);
800
801 if (!osr_initializer_expr ||
802 osr_initializer_expr->getOpcode() != Instruction::GetElementPtr)
803 return false;
804
805 Value *osr_initializer_base = osr_initializer_expr->getOperand(0);
806
807 if (!osr_initializer_base)
808 return false;
809
810 // Find the string's initializer (a ConstantArray) and get the string from it
811
812 GlobalVariable *_objc_meth_var_name_ =
813 dyn_cast<GlobalVariable>(osr_initializer_base);
814
815 if (!_objc_meth_var_name_ || !_objc_meth_var_name_->hasInitializer())
816 return false;
817
818 Constant *omvn_initializer = _objc_meth_var_name_->getInitializer();
819
820 ConstantDataArray *omvn_initializer_array =
821 dyn_cast<ConstantDataArray>(omvn_initializer);
822
823 if (!omvn_initializer_array->isString())
824 return false;
825
826 std::string omvn_initializer_string = omvn_initializer_array->getAsString();
827
828 LLDB_LOG(log, "Found Objective-C selector reference \"{0}\"",
829 omvn_initializer_string);
830
831 // Construct a call to sel_registerName
832
833 if (!m_sel_registerName) {
834 lldb::addr_t sel_registerName_addr;
835
836 bool missing_weak = false;
837 static lldb_private::ConstString g_sel_registerName_str("sel_registerName");
838 sel_registerName_addr = m_execution_unit.FindSymbol(g_sel_registerName_str,
839 missing_weak);
840 if (sel_registerName_addr == LLDB_INVALID_ADDRESS || missing_weak)
841 return false;
842
843 LLDB_LOG(log, "Found sel_registerName at {0}", sel_registerName_addr);
844
845 // Build the function type: struct objc_selector
846 // *sel_registerName(uint8_t*)
847
848 // The below code would be "more correct," but in actuality what's required
849 // is uint8_t*
850 // Type *sel_type = StructType::get(m_module->getContext());
851 // Type *sel_ptr_type = PointerType::getUnqual(sel_type);
852 Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
853
854 Type *type_array[1];
855
856 type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
857
858 ArrayRef<Type *> srN_arg_types(type_array, 1);
859
860 llvm::FunctionType *srN_type =
861 FunctionType::get(sel_ptr_type, srN_arg_types, false);
862
863 // Build the constant containing the pointer to the function
864 PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
865 Constant *srN_addr_int =
866 ConstantInt::get(m_intptr_ty, sel_registerName_addr, false);
867 m_sel_registerName = {srN_type,
868 ConstantExpr::getIntToPtr(srN_addr_int, srN_ptr_ty)};
869 }
870
871 Value *argument_array[1];
872
873 Constant *omvn_pointer = ConstantExpr::getBitCast(
874 _objc_meth_var_name_, Type::getInt8PtrTy(m_module->getContext()));
875
876 argument_array[0] = omvn_pointer;
877
878 ArrayRef<Value *> srN_arguments(argument_array, 1);
879
880 CallInst *srN_call = CallInst::Create(m_sel_registerName, srN_arguments,
881 "sel_registerName", selector_load);
882
883 // Replace the load with the call in all users
884
885 selector_load->replaceAllUsesWith(srN_call);
886
887 selector_load->eraseFromParent();
888
889 return true;
890 }
891
RewriteObjCSelectors(BasicBlock & basic_block)892 bool IRForTarget::RewriteObjCSelectors(BasicBlock &basic_block) {
893 lldb_private::Log *log(
894 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
895
896 InstrList selector_loads;
897
898 for (Instruction &inst : basic_block) {
899 if (LoadInst *load = dyn_cast<LoadInst>(&inst))
900 if (IsObjCSelectorRef(load->getPointerOperand()))
901 selector_loads.push_back(&inst);
902 }
903
904 for (Instruction *inst : selector_loads) {
905 if (!RewriteObjCSelector(inst)) {
906 m_error_stream.Printf("Internal error [IRForTarget]: Couldn't change a "
907 "static reference to an Objective-C selector to a "
908 "dynamic reference\n");
909
910 LLDB_LOG(log, "Couldn't rewrite a reference to an Objective-C selector");
911
912 return false;
913 }
914 }
915
916 return true;
917 }
918
IsObjCClassReference(Value * value)919 static bool IsObjCClassReference(Value *value) {
920 GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
921
922 return !(!global_variable || !global_variable->hasName() ||
923 !global_variable->getName().startswith("OBJC_CLASS_REFERENCES_"));
924 }
925
926 // This function does not report errors; its callers are responsible.
RewriteObjCClassReference(Instruction * class_load)927 bool IRForTarget::RewriteObjCClassReference(Instruction *class_load) {
928 lldb_private::Log *log(
929 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
930
931 LoadInst *load = dyn_cast<LoadInst>(class_load);
932
933 if (!load)
934 return false;
935
936 // Unpack the class name from the reference. In LLVM IR, a reference to an
937 // Objective-C class gets represented as
938 //
939 // %tmp = load %struct._objc_class*,
940 // %struct._objc_class** @OBJC_CLASS_REFERENCES_, align 4
941 //
942 // @"OBJC_CLASS_REFERENCES_ is a bitcast of a character array called
943 // @OBJC_CLASS_NAME_. @OBJC_CLASS_NAME contains the string.
944
945 // Find the pointer's initializer (a ConstantExpr with opcode BitCast) and
946 // get the string from its target
947
948 GlobalVariable *_objc_class_references_ =
949 dyn_cast<GlobalVariable>(load->getPointerOperand());
950
951 if (!_objc_class_references_ ||
952 !_objc_class_references_->hasInitializer())
953 return false;
954
955 Constant *ocr_initializer = _objc_class_references_->getInitializer();
956
957 ConstantExpr *ocr_initializer_expr = dyn_cast<ConstantExpr>(ocr_initializer);
958
959 if (!ocr_initializer_expr ||
960 ocr_initializer_expr->getOpcode() != Instruction::BitCast)
961 return false;
962
963 Value *ocr_initializer_base = ocr_initializer_expr->getOperand(0);
964
965 if (!ocr_initializer_base)
966 return false;
967
968 // Find the string's initializer (a ConstantArray) and get the string from it
969
970 GlobalVariable *_objc_class_name_ =
971 dyn_cast<GlobalVariable>(ocr_initializer_base);
972
973 if (!_objc_class_name_ || !_objc_class_name_->hasInitializer())
974 return false;
975
976 Constant *ocn_initializer = _objc_class_name_->getInitializer();
977
978 ConstantDataArray *ocn_initializer_array =
979 dyn_cast<ConstantDataArray>(ocn_initializer);
980
981 if (!ocn_initializer_array->isString())
982 return false;
983
984 std::string ocn_initializer_string = ocn_initializer_array->getAsString();
985
986 LLDB_LOG(log, "Found Objective-C class reference \"{0}\"",
987 ocn_initializer_string);
988
989 // Construct a call to objc_getClass
990
991 if (!m_objc_getClass) {
992 lldb::addr_t objc_getClass_addr;
993
994 bool missing_weak = false;
995 static lldb_private::ConstString g_objc_getClass_str("objc_getClass");
996 objc_getClass_addr = m_execution_unit.FindSymbol(g_objc_getClass_str,
997 missing_weak);
998 if (objc_getClass_addr == LLDB_INVALID_ADDRESS || missing_weak)
999 return false;
1000
1001 LLDB_LOG(log, "Found objc_getClass at {0}", objc_getClass_addr);
1002
1003 // Build the function type: %struct._objc_class *objc_getClass(i8*)
1004
1005 Type *class_type = load->getType();
1006 Type *type_array[1];
1007 type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
1008
1009 ArrayRef<Type *> ogC_arg_types(type_array, 1);
1010
1011 llvm::FunctionType *ogC_type =
1012 FunctionType::get(class_type, ogC_arg_types, false);
1013
1014 // Build the constant containing the pointer to the function
1015 PointerType *ogC_ptr_ty = PointerType::getUnqual(ogC_type);
1016 Constant *ogC_addr_int =
1017 ConstantInt::get(m_intptr_ty, objc_getClass_addr, false);
1018 m_objc_getClass = {ogC_type,
1019 ConstantExpr::getIntToPtr(ogC_addr_int, ogC_ptr_ty)};
1020 }
1021
1022 Value *argument_array[1];
1023
1024 Constant *ocn_pointer = ConstantExpr::getBitCast(
1025 _objc_class_name_, Type::getInt8PtrTy(m_module->getContext()));
1026
1027 argument_array[0] = ocn_pointer;
1028
1029 ArrayRef<Value *> ogC_arguments(argument_array, 1);
1030
1031 CallInst *ogC_call = CallInst::Create(m_objc_getClass, ogC_arguments,
1032 "objc_getClass", class_load);
1033
1034 // Replace the load with the call in all users
1035
1036 class_load->replaceAllUsesWith(ogC_call);
1037
1038 class_load->eraseFromParent();
1039
1040 return true;
1041 }
1042
RewriteObjCClassReferences(BasicBlock & basic_block)1043 bool IRForTarget::RewriteObjCClassReferences(BasicBlock &basic_block) {
1044 lldb_private::Log *log(
1045 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1046
1047 InstrList class_loads;
1048
1049 for (Instruction &inst : basic_block) {
1050 if (LoadInst *load = dyn_cast<LoadInst>(&inst))
1051 if (IsObjCClassReference(load->getPointerOperand()))
1052 class_loads.push_back(&inst);
1053 }
1054
1055 for (Instruction *inst : class_loads) {
1056 if (!RewriteObjCClassReference(inst)) {
1057 m_error_stream.Printf("Internal error [IRForTarget]: Couldn't change a "
1058 "static reference to an Objective-C class to a "
1059 "dynamic reference\n");
1060
1061 LLDB_LOG(log, "Couldn't rewrite a reference to an Objective-C class");
1062
1063 return false;
1064 }
1065 }
1066
1067 return true;
1068 }
1069
1070 // This function does not report errors; its callers are responsible.
RewritePersistentAlloc(llvm::Instruction * persistent_alloc)1071 bool IRForTarget::RewritePersistentAlloc(llvm::Instruction *persistent_alloc) {
1072 lldb_private::Log *log(
1073 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1074
1075 AllocaInst *alloc = dyn_cast<AllocaInst>(persistent_alloc);
1076
1077 MDNode *alloc_md = alloc->getMetadata("clang.decl.ptr");
1078
1079 if (!alloc_md || !alloc_md->getNumOperands())
1080 return false;
1081
1082 ConstantInt *constant_int =
1083 mdconst::dyn_extract<ConstantInt>(alloc_md->getOperand(0));
1084
1085 if (!constant_int)
1086 return false;
1087
1088 // We attempt to register this as a new persistent variable with the DeclMap.
1089
1090 uintptr_t ptr = constant_int->getZExtValue();
1091
1092 clang::VarDecl *decl = reinterpret_cast<clang::VarDecl *>(ptr);
1093
1094 lldb_private::TypeFromParser result_decl_type(
1095 decl->getType().getAsOpaquePtr(),
1096 lldb_private::ClangASTContext::GetASTContext(&decl->getASTContext()));
1097
1098 StringRef decl_name(decl->getName());
1099 lldb_private::ConstString persistent_variable_name(decl_name.data(),
1100 decl_name.size());
1101 if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name,
1102 result_decl_type, false, false))
1103 return false;
1104
1105 GlobalVariable *persistent_global = new GlobalVariable(
1106 (*m_module), alloc->getType(), false, /* not constant */
1107 GlobalValue::ExternalLinkage, nullptr, /* no initializer */
1108 alloc->getName().str());
1109
1110 // What we're going to do here is make believe this was a regular old
1111 // external variable. That means we need to make the metadata valid.
1112
1113 NamedMDNode *named_metadata =
1114 m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
1115
1116 llvm::Metadata *values[2];
1117 values[0] = ConstantAsMetadata::get(persistent_global);
1118 values[1] = ConstantAsMetadata::get(constant_int);
1119
1120 ArrayRef<llvm::Metadata *> value_ref(values, 2);
1121
1122 MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
1123 named_metadata->addOperand(persistent_global_md);
1124
1125 // Now, since the variable is a pointer variable, we will drop in a load of
1126 // that pointer variable.
1127
1128 LoadInst *persistent_load = new LoadInst(persistent_global, "", alloc);
1129
1130 LLDB_LOG(log, "Replacing \"{0}\" with \"{1}\"", PrintValue(alloc),
1131 PrintValue(persistent_load));
1132
1133 alloc->replaceAllUsesWith(persistent_load);
1134 alloc->eraseFromParent();
1135
1136 return true;
1137 }
1138
RewritePersistentAllocs(llvm::BasicBlock & basic_block)1139 bool IRForTarget::RewritePersistentAllocs(llvm::BasicBlock &basic_block) {
1140 if (!m_resolve_vars)
1141 return true;
1142
1143 lldb_private::Log *log(
1144 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1145
1146 InstrList pvar_allocs;
1147
1148 for (Instruction &inst : basic_block) {
1149
1150 if (AllocaInst *alloc = dyn_cast<AllocaInst>(&inst)) {
1151 llvm::StringRef alloc_name = alloc->getName();
1152
1153 if (alloc_name.startswith("$") && !alloc_name.startswith("$__lldb")) {
1154 if (alloc_name.find_first_of("0123456789") == 1) {
1155 LLDB_LOG(log, "Rejecting a numeric persistent variable.");
1156
1157 m_error_stream.Printf("Error [IRForTarget]: Names starting with $0, "
1158 "$1, ... are reserved for use as result "
1159 "names\n");
1160
1161 return false;
1162 }
1163
1164 pvar_allocs.push_back(alloc);
1165 }
1166 }
1167 }
1168
1169 for (Instruction *inst : pvar_allocs) {
1170 if (!RewritePersistentAlloc(inst)) {
1171 m_error_stream.Printf("Internal error [IRForTarget]: Couldn't rewrite "
1172 "the creation of a persistent variable\n");
1173
1174 LLDB_LOG(log, "Couldn't rewrite the creation of a persistent variable");
1175
1176 return false;
1177 }
1178 }
1179
1180 return true;
1181 }
1182
1183 // This function does not report errors; its callers are responsible.
MaybeHandleVariable(Value * llvm_value_ptr)1184 bool IRForTarget::MaybeHandleVariable(Value *llvm_value_ptr) {
1185 lldb_private::Log *log(
1186 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1187
1188 LLDB_LOG(log, "MaybeHandleVariable ({0})", PrintValue(llvm_value_ptr));
1189
1190 if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(llvm_value_ptr)) {
1191 switch (constant_expr->getOpcode()) {
1192 default:
1193 break;
1194 case Instruction::GetElementPtr:
1195 case Instruction::BitCast:
1196 Value *s = constant_expr->getOperand(0);
1197 if (!MaybeHandleVariable(s))
1198 return false;
1199 }
1200 } else if (GlobalVariable *global_variable =
1201 dyn_cast<GlobalVariable>(llvm_value_ptr)) {
1202 if (!GlobalValue::isExternalLinkage(global_variable->getLinkage()))
1203 return true;
1204
1205 clang::NamedDecl *named_decl = DeclForGlobal(global_variable);
1206
1207 if (!named_decl) {
1208 if (IsObjCSelectorRef(llvm_value_ptr))
1209 return true;
1210
1211 if (!global_variable->hasExternalLinkage())
1212 return true;
1213
1214 LLDB_LOG(log, "Found global variable \"{0}\" without metadata",
1215 global_variable->getName());
1216
1217 return false;
1218 }
1219
1220 llvm::StringRef name(named_decl->getName());
1221
1222 clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl);
1223 if (value_decl == nullptr)
1224 return false;
1225
1226 lldb_private::CompilerType compiler_type(
1227 lldb_private::ClangASTContext::GetASTContext(
1228 &value_decl->getASTContext()),
1229 value_decl->getType().getAsOpaquePtr());
1230
1231 const Type *value_type = nullptr;
1232
1233 if (name.startswith("$")) {
1234 // The $__lldb_expr_result name indicates the return value has allocated
1235 // as a static variable. Per the comment at
1236 // ASTResultSynthesizer::SynthesizeBodyResult, accesses to this static
1237 // variable need to be redirected to the result of dereferencing a
1238 // pointer that is passed in as one of the arguments.
1239 //
1240 // Consequently, when reporting the size of the type, we report a pointer
1241 // type pointing to the type of $__lldb_expr_result, not the type itself.
1242 //
1243 // We also do this for any user-declared persistent variables.
1244 compiler_type = compiler_type.GetPointerType();
1245 value_type = PointerType::get(global_variable->getType(), 0);
1246 } else {
1247 value_type = global_variable->getType();
1248 }
1249
1250 llvm::Optional<uint64_t> value_size = compiler_type.GetByteSize(nullptr);
1251 if (!value_size)
1252 return false;
1253 llvm::Optional<size_t> opt_alignment = compiler_type.GetTypeBitAlign(nullptr);
1254 if (!opt_alignment)
1255 return false;
1256 lldb::offset_t value_alignment = (*opt_alignment + 7ull) / 8ull;
1257
1258 LLDB_LOG(log,
1259 "Type of \"{0}\" is [clang \"{1}\", llvm \"{2}\"] [size {3}, "
1260 "align {4}]",
1261 name,
1262 lldb_private::ClangUtil::GetQualType(compiler_type).getAsString(),
1263 PrintType(value_type), *value_size, value_alignment);
1264
1265 if (named_decl)
1266 m_decl_map->AddValueToStruct(named_decl, lldb_private::ConstString(name),
1267 llvm_value_ptr, *value_size,
1268 value_alignment);
1269 } else if (dyn_cast<llvm::Function>(llvm_value_ptr)) {
1270 LLDB_LOG(log, "Function pointers aren't handled right now");
1271
1272 return false;
1273 }
1274
1275 return true;
1276 }
1277
1278 // This function does not report errors; its callers are responsible.
HandleSymbol(Value * symbol)1279 bool IRForTarget::HandleSymbol(Value *symbol) {
1280 lldb_private::Log *log(
1281 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1282
1283 lldb_private::ConstString name(symbol->getName().str().c_str());
1284
1285 lldb::addr_t symbol_addr =
1286 m_decl_map->GetSymbolAddress(name, lldb::eSymbolTypeAny);
1287
1288 if (symbol_addr == LLDB_INVALID_ADDRESS) {
1289 LLDB_LOG(log, "Symbol \"{0}\" had no address", name);
1290
1291 return false;
1292 }
1293
1294 LLDB_LOG(log, "Found \"{0}\" at {1}", name, symbol_addr);
1295
1296 Type *symbol_type = symbol->getType();
1297
1298 Constant *symbol_addr_int = ConstantInt::get(m_intptr_ty, symbol_addr, false);
1299
1300 Value *symbol_addr_ptr =
1301 ConstantExpr::getIntToPtr(symbol_addr_int, symbol_type);
1302
1303 LLDB_LOG(log, "Replacing {0} with {1}", PrintValue(symbol),
1304 PrintValue(symbol_addr_ptr));
1305
1306 symbol->replaceAllUsesWith(symbol_addr_ptr);
1307
1308 return true;
1309 }
1310
MaybeHandleCallArguments(CallInst * Old)1311 bool IRForTarget::MaybeHandleCallArguments(CallInst *Old) {
1312 lldb_private::Log *log(
1313 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1314
1315 LLDB_LOG(log, "MaybeHandleCallArguments({0})", PrintValue(Old));
1316
1317 for (unsigned op_index = 0, num_ops = Old->getNumArgOperands();
1318 op_index < num_ops; ++op_index)
1319 // conservatively believe that this is a store
1320 if (!MaybeHandleVariable(Old->getArgOperand(op_index))) {
1321 m_error_stream.Printf("Internal error [IRForTarget]: Couldn't rewrite "
1322 "one of the arguments of a function call.\n");
1323
1324 return false;
1325 }
1326
1327 return true;
1328 }
1329
HandleObjCClass(Value * classlist_reference)1330 bool IRForTarget::HandleObjCClass(Value *classlist_reference) {
1331 lldb_private::Log *log(
1332 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1333
1334 GlobalVariable *global_variable =
1335 dyn_cast<GlobalVariable>(classlist_reference);
1336
1337 if (!global_variable)
1338 return false;
1339
1340 Constant *initializer = global_variable->getInitializer();
1341
1342 if (!initializer)
1343 return false;
1344
1345 if (!initializer->hasName())
1346 return false;
1347
1348 StringRef name(initializer->getName());
1349 lldb_private::ConstString name_cstr(name.str().c_str());
1350 lldb::addr_t class_ptr =
1351 m_decl_map->GetSymbolAddress(name_cstr, lldb::eSymbolTypeObjCClass);
1352
1353 LLDB_LOG(log, "Found reference to Objective-C class {0} ({1})", name,
1354 (unsigned long long)class_ptr);
1355
1356 if (class_ptr == LLDB_INVALID_ADDRESS)
1357 return false;
1358
1359 if (global_variable->use_empty())
1360 return false;
1361
1362 SmallVector<LoadInst *, 2> load_instructions;
1363
1364 for (llvm::User *u : global_variable->users()) {
1365 if (LoadInst *load_instruction = dyn_cast<LoadInst>(u))
1366 load_instructions.push_back(load_instruction);
1367 }
1368
1369 if (load_instructions.empty())
1370 return false;
1371
1372 Constant *class_addr = ConstantInt::get(m_intptr_ty, (uint64_t)class_ptr);
1373
1374 for (LoadInst *load_instruction : load_instructions) {
1375 Constant *class_bitcast =
1376 ConstantExpr::getIntToPtr(class_addr, load_instruction->getType());
1377
1378 load_instruction->replaceAllUsesWith(class_bitcast);
1379
1380 load_instruction->eraseFromParent();
1381 }
1382
1383 return true;
1384 }
1385
RemoveCXAAtExit(BasicBlock & basic_block)1386 bool IRForTarget::RemoveCXAAtExit(BasicBlock &basic_block) {
1387 std::vector<CallInst *> calls_to_remove;
1388
1389 for (Instruction &inst : basic_block) {
1390 CallInst *call = dyn_cast<CallInst>(&inst);
1391
1392 // MaybeHandleCallArguments handles error reporting; we are silent here
1393 if (!call)
1394 continue;
1395
1396 bool remove = false;
1397
1398 llvm::Function *func = call->getCalledFunction();
1399
1400 if (func && func->getName() == "__cxa_atexit")
1401 remove = true;
1402
1403 llvm::Value *val = call->getCalledValue();
1404
1405 if (val && val->getName() == "__cxa_atexit")
1406 remove = true;
1407
1408 if (remove)
1409 calls_to_remove.push_back(call);
1410 }
1411
1412 for (CallInst *ci : calls_to_remove)
1413 ci->eraseFromParent();
1414
1415 return true;
1416 }
1417
ResolveCalls(BasicBlock & basic_block)1418 bool IRForTarget::ResolveCalls(BasicBlock &basic_block) {
1419 // Prepare the current basic block for execution in the remote process
1420
1421 for (Instruction &inst : basic_block) {
1422 CallInst *call = dyn_cast<CallInst>(&inst);
1423
1424 // MaybeHandleCallArguments handles error reporting; we are silent here
1425 if (call && !MaybeHandleCallArguments(call))
1426 return false;
1427 }
1428
1429 return true;
1430 }
1431
ResolveExternals(Function & llvm_function)1432 bool IRForTarget::ResolveExternals(Function &llvm_function) {
1433 lldb_private::Log *log(
1434 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1435
1436 for (GlobalVariable &global_var : m_module->globals()) {
1437 llvm::StringRef global_name = global_var.getName();
1438
1439 LLDB_LOG(log, "Examining {0}, DeclForGlobalValue returns {1}", global_name,
1440 static_cast<void *>(DeclForGlobal(&global_var)));
1441
1442 if (global_name.startswith("OBJC_IVAR")) {
1443 if (!HandleSymbol(&global_var)) {
1444 m_error_stream.Format("Error [IRForTarget]: Couldn't find Objective-C "
1445 "indirect ivar symbol {0}\n",
1446 global_name);
1447
1448 return false;
1449 }
1450 } else if (global_name.contains("OBJC_CLASSLIST_REFERENCES_$")) {
1451 if (!HandleObjCClass(&global_var)) {
1452 m_error_stream.Printf("Error [IRForTarget]: Couldn't resolve the class "
1453 "for an Objective-C static method call\n");
1454
1455 return false;
1456 }
1457 } else if (global_name.contains("OBJC_CLASSLIST_SUP_REFS_$")) {
1458 if (!HandleObjCClass(&global_var)) {
1459 m_error_stream.Printf("Error [IRForTarget]: Couldn't resolve the class "
1460 "for an Objective-C static method call\n");
1461
1462 return false;
1463 }
1464 } else if (DeclForGlobal(&global_var)) {
1465 if (!MaybeHandleVariable(&global_var)) {
1466 m_error_stream.Format("Internal error [IRForTarget]: Couldn't rewrite "
1467 "external variable {0}\n",
1468 global_name);
1469
1470 return false;
1471 }
1472 }
1473 }
1474
1475 return true;
1476 }
1477
isGuardVariableRef(Value * V)1478 static bool isGuardVariableRef(Value *V) {
1479 Constant *Old = dyn_cast<Constant>(V);
1480
1481 if (!Old)
1482 return false;
1483
1484 if (auto CE = dyn_cast<ConstantExpr>(V)) {
1485 if (CE->getOpcode() != Instruction::BitCast)
1486 return false;
1487
1488 Old = CE->getOperand(0);
1489 }
1490
1491 GlobalVariable *GV = dyn_cast<GlobalVariable>(Old);
1492
1493 if (!GV || !GV->hasName() || !isGuardVariableSymbol(GV->getName()))
1494 return false;
1495
1496 return true;
1497 }
1498
TurnGuardLoadIntoZero(llvm::Instruction * guard_load)1499 void IRForTarget::TurnGuardLoadIntoZero(llvm::Instruction *guard_load) {
1500 Constant *zero(Constant::getNullValue(guard_load->getType()));
1501 guard_load->replaceAllUsesWith(zero);
1502 guard_load->eraseFromParent();
1503 }
1504
ExciseGuardStore(Instruction * guard_store)1505 static void ExciseGuardStore(Instruction *guard_store) {
1506 guard_store->eraseFromParent();
1507 }
1508
RemoveGuards(BasicBlock & basic_block)1509 bool IRForTarget::RemoveGuards(BasicBlock &basic_block) {
1510 // Eliminate any reference to guard variables found.
1511
1512 InstrList guard_loads;
1513 InstrList guard_stores;
1514
1515 for (Instruction &inst : basic_block) {
1516
1517 if (LoadInst *load = dyn_cast<LoadInst>(&inst))
1518 if (isGuardVariableRef(load->getPointerOperand()))
1519 guard_loads.push_back(&inst);
1520
1521 if (StoreInst *store = dyn_cast<StoreInst>(&inst))
1522 if (isGuardVariableRef(store->getPointerOperand()))
1523 guard_stores.push_back(&inst);
1524 }
1525
1526 for (Instruction *inst : guard_loads)
1527 TurnGuardLoadIntoZero(inst);
1528
1529 for (Instruction *inst : guard_stores)
1530 ExciseGuardStore(inst);
1531
1532 return true;
1533 }
1534
1535 // This function does not report errors; its callers are responsible.
UnfoldConstant(Constant * old_constant,llvm::Function * llvm_function,FunctionValueCache & value_maker,FunctionValueCache & entry_instruction_finder,lldb_private::Stream & error_stream)1536 bool IRForTarget::UnfoldConstant(Constant *old_constant,
1537 llvm::Function *llvm_function,
1538 FunctionValueCache &value_maker,
1539 FunctionValueCache &entry_instruction_finder,
1540 lldb_private::Stream &error_stream) {
1541 SmallVector<User *, 16> users;
1542
1543 // We do this because the use list might change, invalidating our iterator.
1544 // Much better to keep a work list ourselves.
1545 for (llvm::User *u : old_constant->users())
1546 users.push_back(u);
1547
1548 for (size_t i = 0; i < users.size(); ++i) {
1549 User *user = users[i];
1550
1551 if (Constant *constant = dyn_cast<Constant>(user)) {
1552 // synthesize a new non-constant equivalent of the constant
1553
1554 if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant)) {
1555 switch (constant_expr->getOpcode()) {
1556 default:
1557 error_stream.Printf("error [IRForTarget internal]: Unhandled "
1558 "constant expression type: \"%s\"",
1559 PrintValue(constant_expr).c_str());
1560 return false;
1561 case Instruction::BitCast: {
1562 FunctionValueCache bit_cast_maker(
1563 [&value_maker, &entry_instruction_finder, old_constant,
1564 constant_expr](llvm::Function *function) -> llvm::Value * {
1565 // UnaryExpr
1566 // OperandList[0] is value
1567
1568 if (constant_expr->getOperand(0) != old_constant)
1569 return constant_expr;
1570
1571 return new BitCastInst(
1572 value_maker.GetValue(function), constant_expr->getType(),
1573 "", llvm::cast<Instruction>(
1574 entry_instruction_finder.GetValue(function)));
1575 });
1576
1577 if (!UnfoldConstant(constant_expr, llvm_function, bit_cast_maker,
1578 entry_instruction_finder, error_stream))
1579 return false;
1580 } break;
1581 case Instruction::GetElementPtr: {
1582 // GetElementPtrConstantExpr
1583 // OperandList[0] is base
1584 // OperandList[1]... are indices
1585
1586 FunctionValueCache get_element_pointer_maker(
1587 [&value_maker, &entry_instruction_finder, old_constant,
1588 constant_expr](llvm::Function *function) -> llvm::Value * {
1589 Value *ptr = constant_expr->getOperand(0);
1590
1591 if (ptr == old_constant)
1592 ptr = value_maker.GetValue(function);
1593
1594 std::vector<Value *> index_vector;
1595
1596 unsigned operand_index;
1597 unsigned num_operands = constant_expr->getNumOperands();
1598
1599 for (operand_index = 1; operand_index < num_operands;
1600 ++operand_index) {
1601 Value *operand = constant_expr->getOperand(operand_index);
1602
1603 if (operand == old_constant)
1604 operand = value_maker.GetValue(function);
1605
1606 index_vector.push_back(operand);
1607 }
1608
1609 ArrayRef<Value *> indices(index_vector);
1610
1611 return GetElementPtrInst::Create(
1612 nullptr, ptr, indices, "",
1613 llvm::cast<Instruction>(
1614 entry_instruction_finder.GetValue(function)));
1615 });
1616
1617 if (!UnfoldConstant(constant_expr, llvm_function,
1618 get_element_pointer_maker,
1619 entry_instruction_finder, error_stream))
1620 return false;
1621 } break;
1622 }
1623 } else {
1624 error_stream.Printf(
1625 "error [IRForTarget internal]: Unhandled constant type: \"%s\"",
1626 PrintValue(constant).c_str());
1627 return false;
1628 }
1629 } else {
1630 if (Instruction *inst = llvm::dyn_cast<Instruction>(user)) {
1631 if (llvm_function && inst->getParent()->getParent() != llvm_function) {
1632 error_stream.PutCString("error: Capturing non-local variables in "
1633 "expressions is unsupported.\n");
1634 return false;
1635 }
1636 inst->replaceUsesOfWith(
1637 old_constant, value_maker.GetValue(inst->getParent()->getParent()));
1638 } else {
1639 error_stream.Printf(
1640 "error [IRForTarget internal]: Unhandled non-constant type: \"%s\"",
1641 PrintValue(user).c_str());
1642 return false;
1643 }
1644 }
1645 }
1646
1647 if (!isa<GlobalValue>(old_constant)) {
1648 old_constant->destroyConstant();
1649 }
1650
1651 return true;
1652 }
1653
ReplaceVariables(Function & llvm_function)1654 bool IRForTarget::ReplaceVariables(Function &llvm_function) {
1655 if (!m_resolve_vars)
1656 return true;
1657
1658 lldb_private::Log *log(
1659 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1660
1661 m_decl_map->DoStructLayout();
1662
1663 LLDB_LOG(log, "Element arrangement:");
1664
1665 uint32_t num_elements;
1666 uint32_t element_index;
1667
1668 size_t size;
1669 lldb::offset_t alignment;
1670
1671 if (!m_decl_map->GetStructInfo(num_elements, size, alignment))
1672 return false;
1673
1674 Function::arg_iterator iter(llvm_function.arg_begin());
1675
1676 if (iter == llvm_function.arg_end()) {
1677 m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes no "
1678 "arguments (should take at least a struct pointer)");
1679
1680 return false;
1681 }
1682
1683 Argument *argument = &*iter;
1684
1685 if (argument->getName().equals("this")) {
1686 ++iter;
1687
1688 if (iter == llvm_function.arg_end()) {
1689 m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1690 "'this' argument (should take a struct pointer "
1691 "too)");
1692
1693 return false;
1694 }
1695
1696 argument = &*iter;
1697 } else if (argument->getName().equals("self")) {
1698 ++iter;
1699
1700 if (iter == llvm_function.arg_end()) {
1701 m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1702 "'self' argument (should take '_cmd' and a struct "
1703 "pointer too)");
1704
1705 return false;
1706 }
1707
1708 if (!iter->getName().equals("_cmd")) {
1709 m_error_stream.Format("Internal error [IRForTarget]: Wrapper takes '{0}' "
1710 "after 'self' argument (should take '_cmd')",
1711 iter->getName());
1712
1713 return false;
1714 }
1715
1716 ++iter;
1717
1718 if (iter == llvm_function.arg_end()) {
1719 m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1720 "'self' and '_cmd' arguments (should take a struct "
1721 "pointer too)");
1722
1723 return false;
1724 }
1725
1726 argument = &*iter;
1727 }
1728
1729 if (!argument->getName().equals("$__lldb_arg")) {
1730 m_error_stream.Format("Internal error [IRForTarget]: Wrapper takes an "
1731 "argument named '{0}' instead of the struct pointer",
1732 argument->getName());
1733
1734 return false;
1735 }
1736
1737 LLDB_LOG(log, "Arg: \"{0}\"", PrintValue(argument));
1738
1739 BasicBlock &entry_block(llvm_function.getEntryBlock());
1740 Instruction *FirstEntryInstruction(entry_block.getFirstNonPHIOrDbg());
1741
1742 if (!FirstEntryInstruction) {
1743 m_error_stream.Printf("Internal error [IRForTarget]: Couldn't find the "
1744 "first instruction in the wrapper for use in "
1745 "rewriting");
1746
1747 return false;
1748 }
1749
1750 LLVMContext &context(m_module->getContext());
1751 IntegerType *offset_type(Type::getInt32Ty(context));
1752
1753 if (!offset_type) {
1754 m_error_stream.Printf(
1755 "Internal error [IRForTarget]: Couldn't produce an offset type");
1756
1757 return false;
1758 }
1759
1760 for (element_index = 0; element_index < num_elements; ++element_index) {
1761 const clang::NamedDecl *decl = nullptr;
1762 Value *value = nullptr;
1763 lldb::offset_t offset;
1764 lldb_private::ConstString name;
1765
1766 if (!m_decl_map->GetStructElement(decl, value, offset, name,
1767 element_index)) {
1768 m_error_stream.Printf(
1769 "Internal error [IRForTarget]: Structure information is incomplete");
1770
1771 return false;
1772 }
1773
1774 LLDB_LOG(log, " \"{0}\" (\"{1}\") placed at {2}", name,
1775 decl->getNameAsString(), offset);
1776
1777 if (value) {
1778 LLDB_LOG(log, " Replacing [{0}]", PrintValue(value));
1779
1780 FunctionValueCache body_result_maker(
1781 [this, name, offset_type, offset, argument,
1782 value](llvm::Function *function) -> llvm::Value * {
1783 // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
1784 // in cases where the result variable is an rvalue, we have to
1785 // synthesize a dereference of the appropriate structure entry in
1786 // order to produce the static variable that the AST thinks it is
1787 // accessing.
1788
1789 llvm::Instruction *entry_instruction = llvm::cast<Instruction>(
1790 m_entry_instruction_finder.GetValue(function));
1791
1792 ConstantInt *offset_int(
1793 ConstantInt::get(offset_type, offset, true));
1794 GetElementPtrInst *get_element_ptr = GetElementPtrInst::Create(
1795 nullptr, argument, offset_int, "", entry_instruction);
1796
1797 if (name == m_result_name && !m_result_is_pointer) {
1798 BitCastInst *bit_cast = new BitCastInst(
1799 get_element_ptr, value->getType()->getPointerTo(), "",
1800 entry_instruction);
1801
1802 LoadInst *load = new LoadInst(bit_cast, "", entry_instruction);
1803
1804 return load;
1805 } else {
1806 BitCastInst *bit_cast = new BitCastInst(
1807 get_element_ptr, value->getType(), "", entry_instruction);
1808
1809 return bit_cast;
1810 }
1811 });
1812
1813 if (Constant *constant = dyn_cast<Constant>(value)) {
1814 if (!UnfoldConstant(constant, &llvm_function, body_result_maker,
1815 m_entry_instruction_finder, m_error_stream)) {
1816 return false;
1817 }
1818 } else if (Instruction *instruction = dyn_cast<Instruction>(value)) {
1819 if (instruction->getParent()->getParent() != &llvm_function) {
1820 m_error_stream.PutCString("error: Capturing non-local variables in "
1821 "expressions is unsupported.\n");
1822 return false;
1823 }
1824 value->replaceAllUsesWith(
1825 body_result_maker.GetValue(instruction->getParent()->getParent()));
1826 } else {
1827 LLDB_LOG(log, "Unhandled non-constant type: \"{0}\"",
1828 PrintValue(value));
1829 return false;
1830 }
1831
1832 if (GlobalVariable *var = dyn_cast<GlobalVariable>(value))
1833 var->eraseFromParent();
1834 }
1835 }
1836
1837 LLDB_LOG(log, "Total structure [align {0}, size {1}]", (int64_t)alignment,
1838 (uint64_t)size);
1839
1840 return true;
1841 }
1842
runOnModule(Module & llvm_module)1843 bool IRForTarget::runOnModule(Module &llvm_module) {
1844 lldb_private::Log *log(
1845 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1846
1847 m_module = &llvm_module;
1848 m_target_data.reset(new DataLayout(m_module));
1849 m_intptr_ty = llvm::Type::getIntNTy(m_module->getContext(),
1850 m_target_data->getPointerSizeInBits());
1851
1852 if (log) {
1853 std::string s;
1854 raw_string_ostream oss(s);
1855
1856 m_module->print(oss, nullptr);
1857
1858 oss.flush();
1859
1860 LLDB_LOG(log, "Module as passed in to IRForTarget: \n\"{0}\"", s);
1861 }
1862
1863 Function *const main_function =
1864 m_func_name.IsEmpty() ? nullptr
1865 : m_module->getFunction(m_func_name.GetStringRef());
1866
1867 if (!m_func_name.IsEmpty() && !main_function) {
1868 LLDB_LOG(log, "Couldn't find \"{0}()\" in the module", m_func_name);
1869
1870 m_error_stream.Format("Internal error [IRForTarget]: Couldn't find wrapper "
1871 "'{0}' in the module",
1872 m_func_name);
1873
1874 return false;
1875 }
1876
1877 if (main_function) {
1878 if (!FixFunctionLinkage(*main_function)) {
1879 LLDB_LOG(log, "Couldn't fix the linkage for the function");
1880
1881 return false;
1882 }
1883 }
1884
1885 llvm::Type *int8_ty = Type::getInt8Ty(m_module->getContext());
1886
1887 m_reloc_placeholder = new llvm::GlobalVariable(
1888 (*m_module), int8_ty, false /* IsConstant */,
1889 GlobalVariable::InternalLinkage, Constant::getNullValue(int8_ty),
1890 "reloc_placeholder", nullptr /* InsertBefore */,
1891 GlobalVariable::NotThreadLocal /* ThreadLocal */, 0 /* AddressSpace */);
1892
1893 ////////////////////////////////////////////////////////////
1894 // Replace $__lldb_expr_result with a persistent variable
1895 //
1896
1897 if (main_function) {
1898 if (!CreateResultVariable(*main_function)) {
1899 LLDB_LOG(log, "CreateResultVariable() failed");
1900
1901 // CreateResultVariable() reports its own errors, so we don't do so here
1902
1903 return false;
1904 }
1905 }
1906
1907 if (log && log->GetVerbose()) {
1908 std::string s;
1909 raw_string_ostream oss(s);
1910
1911 m_module->print(oss, nullptr);
1912
1913 oss.flush();
1914
1915 LLDB_LOG(log, "Module after creating the result variable: \n\"{0}\"", s);
1916 }
1917
1918 for (llvm::Function &function : *m_module) {
1919 for (BasicBlock &bb : function) {
1920 if (!RemoveGuards(bb)) {
1921 LLDB_LOG(log, "RemoveGuards() failed");
1922
1923 // RemoveGuards() reports its own errors, so we don't do so here
1924
1925 return false;
1926 }
1927
1928 if (!RewritePersistentAllocs(bb)) {
1929 LLDB_LOG(log, "RewritePersistentAllocs() failed");
1930
1931 // RewritePersistentAllocs() reports its own errors, so we don't do so
1932 // here
1933
1934 return false;
1935 }
1936
1937 if (!RemoveCXAAtExit(bb)) {
1938 LLDB_LOG(log, "RemoveCXAAtExit() failed");
1939
1940 // RemoveCXAAtExit() reports its own errors, so we don't do so here
1941
1942 return false;
1943 }
1944 }
1945 }
1946
1947 ///////////////////////////////////////////////////////////////////////////////
1948 // Fix all Objective-C constant strings to use NSStringWithCString:encoding:
1949 //
1950
1951 if (!RewriteObjCConstStrings()) {
1952 LLDB_LOG(log, "RewriteObjCConstStrings() failed");
1953
1954 // RewriteObjCConstStrings() reports its own errors, so we don't do so here
1955
1956 return false;
1957 }
1958
1959 for (llvm::Function &function : *m_module) {
1960 for (llvm::BasicBlock &bb : function) {
1961 if (!RewriteObjCSelectors(bb)) {
1962 LLDB_LOG(log, "RewriteObjCSelectors() failed");
1963
1964 // RewriteObjCSelectors() reports its own errors, so we don't do so
1965 // here
1966
1967 return false;
1968 }
1969
1970 if (!RewriteObjCClassReferences(bb)) {
1971 LLDB_LOG(log, "RewriteObjCClassReferences() failed");
1972
1973 // RewriteObjCClasses() reports its own errors, so we don't do so here
1974
1975 return false;
1976 }
1977 }
1978 }
1979
1980 for (llvm::Function &function : *m_module) {
1981 for (BasicBlock &bb : function) {
1982 if (!ResolveCalls(bb)) {
1983 LLDB_LOG(log, "ResolveCalls() failed");
1984
1985 // ResolveCalls() reports its own errors, so we don't do so here
1986
1987 return false;
1988 }
1989 }
1990 }
1991
1992 ////////////////////////////////////////////////////////////////////////
1993 // Run function-level passes that only make sense on the main function
1994 //
1995
1996 if (main_function) {
1997 if (!ResolveExternals(*main_function)) {
1998 LLDB_LOG(log, "ResolveExternals() failed");
1999
2000 // ResolveExternals() reports its own errors, so we don't do so here
2001
2002 return false;
2003 }
2004
2005 if (!ReplaceVariables(*main_function)) {
2006 LLDB_LOG(log, "ReplaceVariables() failed");
2007
2008 // ReplaceVariables() reports its own errors, so we don't do so here
2009
2010 return false;
2011 }
2012 }
2013
2014 if (log && log->GetVerbose()) {
2015 std::string s;
2016 raw_string_ostream oss(s);
2017
2018 m_module->print(oss, nullptr);
2019
2020 oss.flush();
2021
2022 LLDB_LOG(log, "Module after preparing for execution: \n\"{0}\"", s);
2023 }
2024
2025 return true;
2026 }
2027
assignPassManager(PMStack & pass_mgr_stack,PassManagerType pass_mgr_type)2028 void IRForTarget::assignPassManager(PMStack &pass_mgr_stack,
2029 PassManagerType pass_mgr_type) {}
2030
getPotentialPassManagerType() const2031 PassManagerType IRForTarget::getPotentialPassManagerType() const {
2032 return PMT_ModulePassManager;
2033 }
2034