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
42using namespace llvm;
43
44static char ID;
45
46typedef SmallVector<Instruction *, 2> InstrList;
47
48IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
49    : m_maker(maker), m_values() {}
50
51IRForTarget::FunctionValueCache::~FunctionValueCache() {}
52
53llvm::Value *
54IRForTarget::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
63static llvm::Value *FindEntryInstruction(llvm::Function *function) {
64  if (function->empty())
65    return nullptr;
66
67  return function->getEntryBlock().getFirstNonPHIOrDbg();
68}
69
70IRForTarget::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
86static 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
98static 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
108IRForTarget::~IRForTarget() {}
109
110bool IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function) {
111  llvm_function.setLinkage(GlobalValue::ExternalLinkage);
112
113  return true;
114}
115
116clang::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
154clang::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.
159static 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
167bool 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
414bool 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
553bool 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
758static 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.
766bool 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
892bool 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
919static 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.
927bool 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
1043bool 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.
1071bool 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
1139bool 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.
1184bool 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.
1279bool 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
1311bool 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
1330bool 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
1386bool 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
1418bool 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
1432bool 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
1478static 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
1499void 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
1505static void ExciseGuardStore(Instruction *guard_store) {
1506  guard_store->eraseFromParent();
1507}
1508
1509bool 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.
1536bool 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
1654bool 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
1843bool 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
2028void IRForTarget::assignPassManager(PMStack &pass_mgr_stack,
2029                                    PassManagerType pass_mgr_type) {}
2030
2031PassManagerType IRForTarget::getPotentialPassManagerType() const {
2032  return PMT_ModulePassManager;
2033}
2034