lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

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