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     if (truncate)
  90       s.resize(s.length() - 1);
  91   }
  92   return s;
  93 }
  94
  95 static std::string PrintType(const llvm::Type *type, bool truncate = false) {
  96   std::string s;
  97   raw_string_ostream rso(s);
  98   type->print(rso);
  99   if (truncate)
 100     s.resize(s.length() - 1);
 101   return s;
 102 }
 103
 104 bool IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function) {
 105   llvm_function.setLinkage(GlobalValue::ExternalLinkage);
 106
 107   return true;
 108 }
 109
 110 clang::NamedDecl *IRForTarget::DeclForGlobal(const GlobalValue *global_val,
 111                                              Module *module) {
 112   NamedMDNode *named_metadata =
 113       module->getNamedMetadata("clang.global.decl.ptrs");
 114
 115   if (!named_metadata)
 116     return nullptr;
 117
 118   unsigned num_nodes = named_metadata->getNumOperands();
 119   unsigned node_index;
 120
 121   for (node_index = 0; node_index < num_nodes; ++node_index) {
 122     llvm::MDNode *metadata_node =
 123         dyn_cast<llvm::MDNode>(named_metadata->getOperand(node_index));
 124     if (!metadata_node)
 125       return nullptr;
 126
 127     if (metadata_node->getNumOperands() != 2)
 128       continue;
 129
 130     if (mdconst::dyn_extract_or_null<GlobalValue>(
 131             metadata_node->getOperand(0)) != global_val)
 132       continue;
 133
 134     ConstantInt *constant_int =
 135         mdconst::dyn_extract<ConstantInt>(metadata_node->getOperand(1));
 136
 137     if (!constant_int)
 138       return nullptr;
 139
 140     uintptr_t ptr = constant_int->getZExtValue();
 141
 142     return reinterpret_cast<clang::NamedDecl *>(ptr);
 143   }
 144
 145   return nullptr;
 146 }
 147
 148 clang::NamedDecl *IRForTarget::DeclForGlobal(GlobalValue *global_val) {
 149   return DeclForGlobal(global_val, m_module);
 150 }
 151
 152 /// Returns true iff the mangled symbol is for a static guard variable.
 153 static bool isGuardVariableSymbol(llvm::StringRef mangled_symbol,
 154                                   bool check_ms_abi = true) {
 155   bool result =
 156       mangled_symbol.starts_with("_ZGV"); // Itanium ABI guard variable
 157   if (check_ms_abi)
 158     result |= mangled_symbol.ends_with("@4IA"); // Microsoft ABI
 159   return result;
 160 }
 161
 162 bool IRForTarget::CreateResultVariable(llvm::Function &llvm_function) {
 163   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 164
 165   if (!m_resolve_vars)
 166     return true;
 167
 168   // Find the result variable.  If it doesn't exist, we can give up right here.
 169
 170   ValueSymbolTable &value_symbol_table = m_module->getValueSymbolTable();
 171
 172   llvm::StringRef result_name;
 173   bool found_result = false;
 174
 175   for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
 176     result_name = value_symbol.first();
 177
 178     // Check if this is a guard variable. It seems this causes some hiccups
 179     // on Windows, so let's only check for Itanium guard variables.
 180     bool is_guard_var = isGuardVariableSymbol(result_name, /*MS ABI*/ false);
 181
 182     if (result_name.contains("$__lldb_expr_result_ptr") && !is_guard_var) {
 183       found_result = true;
 184       m_result_is_pointer = true;
 185       break;
 186     }
 187
 188     if (result_name.contains("$__lldb_expr_result") && !is_guard_var) {
 189       found_result = true;
 190       m_result_is_pointer = false;
 191       break;
 192     }
 193   }
 194
 195   if (!found_result) {
 196     LLDB_LOG(log, "Couldn't find result variable");
 197
 198     return true;
 199   }
 200
 201   LLDB_LOG(log, "Result name: \"{0}\"", result_name);
 202
 203   Value *result_value = m_module->getNamedValue(result_name);
 204
 205   if (!result_value) {
 206     LLDB_LOG(log, "Result variable had no data");
 207
 208     m_error_stream.Format("Internal error [IRForTarget]: Result variable's "
 209                           "name ({0}) exists, but not its definition\n",
 210                           result_name);
 211
 212     return false;
 213   }
 214
 215   LLDB_LOG(log, "Found result in the IR: \"{0}\"",
 216            PrintValue(result_value, false));
 217
 218   GlobalVariable *result_global = dyn_cast<GlobalVariable>(result_value);
 219
 220   if (!result_global) {
 221     LLDB_LOG(log, "Result variable isn't a GlobalVariable");
 222
 223     m_error_stream.Format("Internal error [IRForTarget]: Result variable ({0}) "
 224                           "is defined, but is not a global variable\n",
 225                           result_name);
 226
 227     return false;
 228   }
 229
 230   clang::NamedDecl *result_decl = DeclForGlobal(result_global);
 231   if (!result_decl) {
 232     LLDB_LOG(log, "Result variable doesn't have a corresponding Decl");
 233
 234     m_error_stream.Format("Internal error [IRForTarget]: Result variable ({0}) "
 235                           "does not have a corresponding Clang entity\n",
 236                           result_name);
 237
 238     return false;
 239   }
 240
 241   if (log) {
 242     std::string decl_desc_str;
 243     raw_string_ostream decl_desc_stream(decl_desc_str);
 244     result_decl->print(decl_desc_stream);
 245
 246     LLDB_LOG(log, "Found result decl: \"{0}\"", decl_desc_str);
 247   }
 248
 249   clang::VarDecl *result_var = dyn_cast<clang::VarDecl>(result_decl);
 250   if (!result_var) {
 251     LLDB_LOG(log, "Result variable Decl isn't a VarDecl");
 252
 253     m_error_stream.Format("Internal error [IRForTarget]: Result variable "
 254                           "({0})'s corresponding Clang entity isn't a "
 255                           "variable\n",
 256                           result_name);
 257
 258     return false;
 259   }
 260
 261   // Get the next available result name from m_decl_map and create the
 262   // persistent variable for it
 263
 264   // If the result is an Lvalue, it is emitted as a pointer; see
 265   // ASTResultSynthesizer::SynthesizeBodyResult.
 266   if (m_result_is_pointer) {
 267     clang::QualType pointer_qual_type = result_var->getType();
 268     const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
 269
 270     const clang::PointerType *pointer_pointertype =
 271         pointer_type->getAs<clang::PointerType>();
 272     const clang::ObjCObjectPointerType *pointer_objcobjpointertype =
 273         pointer_type->getAs<clang::ObjCObjectPointerType>();
 274
 275     if (pointer_pointertype) {
 276       clang::QualType element_qual_type = pointer_pointertype->getPointeeType();
 277
 278       m_result_type = lldb_private::TypeFromParser(
 279           m_decl_map->GetTypeSystem()->GetType(element_qual_type));
 280     } else if (pointer_objcobjpointertype) {
 281       clang::QualType element_qual_type =
 282           clang::QualType(pointer_objcobjpointertype->getObjectType(), 0);
 283
 284       m_result_type = lldb_private::TypeFromParser(
 285           m_decl_map->GetTypeSystem()->GetType(element_qual_type));
 286     } else {
 287       LLDB_LOG(log, "Expected result to have pointer type, but it did not");
 288
 289       m_error_stream.Format("Internal error [IRForTarget]: Lvalue result ({0}) "
 290                             "is not a pointer variable\n",
 291                             result_name);
 292
 293       return false;
 294     }
 295   } else {
 296     m_result_type = lldb_private::TypeFromParser(
 297         m_decl_map->GetTypeSystem()->GetType(result_var->getType()));
 298   }
 299
 300   lldb::TargetSP target_sp(m_execution_unit.GetTarget());
 301   std::optional<uint64_t> bit_size = m_result_type.GetBitSize(target_sp.get());
 302   if (!bit_size) {
 303     lldb_private::StreamString type_desc_stream;
 304     m_result_type.DumpTypeDescription(&type_desc_stream);
 305
 306     LLDB_LOG(log, "Result type has unknown size");
 307
 308     m_error_stream.Printf("Error [IRForTarget]: Size of result type '%s' "
 309                           "couldn't be determined\n",
 310                           type_desc_stream.GetData());
 311     return false;
 312   }
 313
 314   if (log) {
 315     lldb_private::StreamString type_desc_stream;
 316     m_result_type.DumpTypeDescription(&type_desc_stream);
 317
 318     LLDB_LOG(log, "Result decl type: \"{0}\"", type_desc_stream.GetData());
 319   }
 320
 321   m_result_name = lldb_private::ConstString("$RESULT_NAME");
 322
 323   LLDB_LOG(log, "Creating a new result global: \"{0}\" with size {1}",
 324            m_result_name,
 325            m_result_type.GetByteSize(target_sp.get()).value_or(0));
 326
 327   // Construct a new result global and set up its metadata
 328
 329   GlobalVariable *new_result_global = new GlobalVariable(
 330       (*m_module), result_global->getValueType(), false, /* not constant */
 331       GlobalValue::ExternalLinkage, nullptr,             /* no initializer */
 332       m_result_name.GetCString());
 333
 334   // It's too late in compilation to create a new VarDecl for this, but we
 335   // don't need to.  We point the metadata at the old VarDecl.  This creates an
 336   // odd anomaly: a variable with a Value whose name is something like $0 and a
 337   // Decl whose name is $__lldb_expr_result.  This condition is handled in
 338   // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
 339   // fixed up.
 340
 341   ConstantInt *new_constant_int =
 342       ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
 343                        reinterpret_cast<uintptr_t>(result_decl), false);
 344
 345   llvm::Metadata *values[2];
 346   values[0] = ConstantAsMetadata::get(new_result_global);
 347   values[1] = ConstantAsMetadata::get(new_constant_int);
 348
 349   ArrayRef<Metadata *> value_ref(values, 2);
 350
 351   MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
 352   NamedMDNode *named_metadata =
 353       m_module->getNamedMetadata("clang.global.decl.ptrs");
 354   named_metadata->addOperand(persistent_global_md);
 355
 356   LLDB_LOG(log, "Replacing \"{0}\" with \"{1}\"", PrintValue(result_global),
 357            PrintValue(new_result_global));
 358
 359   if (result_global->use_empty()) {
 360     // We need to synthesize a store for this variable, because otherwise
 361     // there's nothing to put into its equivalent persistent variable.
 362
 363     BasicBlock &entry_block(llvm_function.getEntryBlock());
 364     Instruction *first_entry_instruction(entry_block.getFirstNonPHIOrDbg());
 365
 366     if (!first_entry_instruction)
 367       return false;
 368
 369     if (!result_global->hasInitializer()) {
 370       LLDB_LOG(log, "Couldn't find initializer for unused variable");
 371
 372       m_error_stream.Format("Internal error [IRForTarget]: Result variable "
 373                             "({0}) has no writes and no initializer\n",
 374                             result_name);
 375
 376       return false;
 377     }
 378
 379     Constant *initializer = result_global->getInitializer();
 380
 381     StoreInst *synthesized_store = new StoreInst(
 382         initializer, new_result_global, first_entry_instruction->getIterator());
 383
 384     LLDB_LOG(log, "Synthesized result store \"{0}\"\n",
 385              PrintValue(synthesized_store));
 386   } else {
 387     result_global->replaceAllUsesWith(new_result_global);
 388   }
 389
 390   if (!m_decl_map->AddPersistentVariable(
 391           result_decl, m_result_name, m_result_type, true, m_result_is_pointer))
 392     return false;
 393
 394   result_global->eraseFromParent();
 395
 396   return true;
 397 }
 398
 399 bool IRForTarget::RewriteObjCConstString(llvm::GlobalVariable *ns_str,
 400                                          llvm::GlobalVariable *cstr) {
 401   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 402
 403   Type *ns_str_ty = ns_str->getType();
 404
 405   Type *i8_ptr_ty = PointerType::getUnqual(m_module->getContext());
 406   Type *i32_ty = Type::getInt32Ty(m_module->getContext());
 407   Type *i8_ty = Type::getInt8Ty(m_module->getContext());
 408
 409   if (!m_CFStringCreateWithBytes) {
 410     lldb::addr_t CFStringCreateWithBytes_addr;
 411
 412     static lldb_private::ConstString g_CFStringCreateWithBytes_str(
 413         "CFStringCreateWithBytes");
 414
 415     bool missing_weak = false;
 416     CFStringCreateWithBytes_addr = m_execution_unit.FindSymbol(
 417         g_CFStringCreateWithBytes_str, missing_weak);
 418     if (CFStringCreateWithBytes_addr == LLDB_INVALID_ADDRESS || missing_weak) {
 419       LLDB_LOG(log, "Couldn't find CFStringCreateWithBytes in the target");
 420
 421       m_error_stream.Printf("Error [IRForTarget]: Rewriting an Objective-C "
 422                             "constant string requires "
 423                             "CFStringCreateWithBytes\n");
 424
 425       return false;
 426     }
 427
 428     LLDB_LOG(log, "Found CFStringCreateWithBytes at {0}",
 429              CFStringCreateWithBytes_addr);
 430
 431     // Build the function type:
 432     //
 433     // CFStringRef CFStringCreateWithBytes (
 434     //   CFAllocatorRef alloc,
 435     //   const UInt8 *bytes,
 436     //   CFIndex numBytes,
 437     //   CFStringEncoding encoding,
 438     //   Boolean isExternalRepresentation
 439     // );
 440     //
 441     // We make the following substitutions:
 442     //
 443     // CFStringRef -> i8*
 444     // CFAllocatorRef -> i8*
 445     // UInt8 * -> i8*
 446     // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its
 447     // pointer size for now) CFStringEncoding -> i32 Boolean -> i8
 448
 449     Type *arg_type_array[5];
 450
 451     arg_type_array[0] = i8_ptr_ty;
 452     arg_type_array[1] = i8_ptr_ty;
 453     arg_type_array[2] = m_intptr_ty;
 454     arg_type_array[3] = i32_ty;
 455     arg_type_array[4] = i8_ty;
 456
 457     ArrayRef<Type *> CFSCWB_arg_types(arg_type_array, 5);
 458
 459     llvm::FunctionType *CFSCWB_ty =
 460         FunctionType::get(ns_str_ty, CFSCWB_arg_types, false);
 461
 462     // Build the constant containing the pointer to the function
 463     PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
 464     Constant *CFSCWB_addr_int =
 465         ConstantInt::get(m_intptr_ty, CFStringCreateWithBytes_addr, false);
 466     m_CFStringCreateWithBytes = {
 467         CFSCWB_ty, ConstantExpr::getIntToPtr(CFSCWB_addr_int, CFSCWB_ptr_ty)};
 468   }
 469
 470   ConstantDataSequential *string_array = nullptr;
 471
 472   if (cstr)
 473     string_array = dyn_cast<ConstantDataSequential>(cstr->getInitializer());
 474
 475   Constant *alloc_arg = Constant::getNullValue(i8_ptr_ty);
 476   Constant *bytes_arg = cstr ? cstr : Constant::getNullValue(i8_ptr_ty);
 477   Constant *numBytes_arg = ConstantInt::get(
 478       m_intptr_ty, cstr ? (string_array->getNumElements() - 1) * string_array->getElementByteSize() : 0, false);
 479  int encoding_flags = 0;
 480  switch (cstr ? string_array->getElementByteSize() : 1) {
 481  case 1:
 482    encoding_flags = 0x08000100; /* 0x08000100 is kCFStringEncodingUTF8 */
 483    break;
 484  case 2:
 485    encoding_flags = 0x0100; /* 0x0100 is kCFStringEncodingUTF16 */
 486    break;
 487  case 4:
 488    encoding_flags = 0x0c000100; /* 0x0c000100 is kCFStringEncodingUTF32 */
 489    break;
 490  default:
 491    encoding_flags = 0x0600; /* fall back to 0x0600, kCFStringEncodingASCII */
 492    LLDB_LOG(log, "Encountered an Objective-C constant string with unusual "
 493                  "element size {0}",
 494             string_array->getElementByteSize());
 495  }
 496  Constant *encoding_arg = ConstantInt::get(i32_ty, encoding_flags, false);
 497  Constant *isExternal_arg =
 498      ConstantInt::get(i8_ty, 0x0, false); /* 0x0 is false */
 499
 500  Value *argument_array[5];
 501
 502  argument_array[0] = alloc_arg;
 503  argument_array[1] = bytes_arg;
 504  argument_array[2] = numBytes_arg;
 505  argument_array[3] = encoding_arg;
 506  argument_array[4] = isExternal_arg;
 507
 508  ArrayRef<Value *> CFSCWB_arguments(argument_array, 5);
 509
 510  FunctionValueCache CFSCWB_Caller(
 511      [this, &CFSCWB_arguments](llvm::Function *function) -> llvm::Value * {
 512        return CallInst::Create(
 513            m_CFStringCreateWithBytes, CFSCWB_arguments,
 514            "CFStringCreateWithBytes",
 515            llvm::cast<Instruction>(
 516                m_entry_instruction_finder.GetValue(function))
 517                ->getIterator());
 518      });
 519
 520  if (!UnfoldConstant(ns_str, nullptr, CFSCWB_Caller, m_entry_instruction_finder,
 521                      m_error_stream)) {
 522    LLDB_LOG(log, "Couldn't replace the NSString with the result of the call");
 523
 524    m_error_stream.Printf("error [IRForTarget internal]: Couldn't replace an "
 525                          "Objective-C constant string with a dynamic "
 526                          "string\n");
 527
 528    return false;
 529   }
 530
 531   ns_str->eraseFromParent();
 532
 533   return true;
 534 }
 535
 536 bool IRForTarget::RewriteObjCConstStrings() {
 537   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 538
 539   ValueSymbolTable &value_symbol_table = m_module->getValueSymbolTable();
 540
 541   for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
 542     llvm::StringRef value_name = value_symbol.first();
 543
 544     if (value_name.contains("_unnamed_cfstring_")) {
 545       Value *nsstring_value = value_symbol.second;
 546
 547       GlobalVariable *nsstring_global =
 548           dyn_cast<GlobalVariable>(nsstring_value);
 549
 550       if (!nsstring_global) {
 551         LLDB_LOG(log, "NSString variable is not a GlobalVariable");
 552
 553         m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
 554                               "constant string is not a global variable\n");
 555
 556         return false;
 557       }
 558
 559       if (!nsstring_global->hasInitializer()) {
 560         LLDB_LOG(log, "NSString variable does not have an initializer");
 561
 562         m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
 563                               "constant string does not have an initializer\n");
 564
 565         return false;
 566       }
 567
 568       ConstantStruct *nsstring_struct =
 569           dyn_cast<ConstantStruct>(nsstring_global->getInitializer());
 570
 571       if (!nsstring_struct) {
 572         LLDB_LOG(log,
 573                  "NSString variable's initializer is not a ConstantStruct");
 574
 575         m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
 576                               "constant string is not a structure constant\n");
 577
 578         return false;
 579       }
 580
 581       // We expect the following structure:
 582       //
 583       // struct {
 584       //   int *isa;
 585       //   int flags;
 586       //   char *str;
 587       //   long length;
 588       // };
 589
 590       if (nsstring_struct->getNumOperands() != 4) {
 591
 592         LLDB_LOG(log,
 593                  "NSString variable's initializer structure has an "
 594                  "unexpected number of members.  Should be 4, is {0}",
 595                  nsstring_struct->getNumOperands());
 596
 597         m_error_stream.Printf("Internal error [IRForTarget]: The struct for an "
 598                               "Objective-C constant string is not as "
 599                               "expected\n");
 600
 601         return false;
 602       }
 603
 604       Constant *nsstring_member = nsstring_struct->getOperand(2);
 605
 606       if (!nsstring_member) {
 607         LLDB_LOG(log, "NSString initializer's str element was empty");
 608
 609         m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
 610                               "constant string does not have a string "
 611                               "initializer\n");
 612
 613         return false;
 614       }
 615
 616       auto *cstr_global = dyn_cast<GlobalVariable>(nsstring_member);
 617       if (!cstr_global) {
 618         LLDB_LOG(log,
 619                  "NSString initializer's str element is not a GlobalVariable");
 620
 621         m_error_stream.Printf("Internal error [IRForTarget]: Unhandled"
 622                               "constant string initializer\n");
 623
 624         return false;
 625       }
 626
 627       if (!cstr_global->hasInitializer()) {
 628         LLDB_LOG(log, "NSString initializer's str element does not have an "
 629                       "initializer");
 630
 631         m_error_stream.Printf("Internal error [IRForTarget]: An Objective-C "
 632                               "constant string's string initializer doesn't "
 633                               "point to initialized data\n");
 634
 635         return false;
 636       }
 637
 638       /*
 639       if (!cstr_array)
 640       {
 641           if (log)
 642               log->PutCString("NSString initializer's str element is not a
 643       ConstantArray");
 644
 645           if (m_error_stream)
 646               m_error_stream.Printf("Internal error [IRForTarget]: An
 647       Objective-C constant string's string initializer doesn't point to an
 648       array\n");
 649
 650           return false;
 651       }
 652
 653       if (!cstr_array->isCString())
 654       {
 655           if (log)
 656               log->PutCString("NSString initializer's str element is not a C
 657       string array");
 658
 659           if (m_error_stream)
 660               m_error_stream.Printf("Internal error [IRForTarget]: An
 661       Objective-C constant string's string initializer doesn't point to a C
 662       string\n");
 663
 664           return false;
 665       }
 666       */
 667
 668       ConstantDataArray *cstr_array =
 669           dyn_cast<ConstantDataArray>(cstr_global->getInitializer());
 670
 671       if (cstr_array)
 672         LLDB_LOG(log, "Found NSString constant {0}, which contains \"{1}\"",
 673                  value_name, cstr_array->getAsString());
 674       else
 675         LLDB_LOG(log, "Found NSString constant {0}, which contains \"\"",
 676                  value_name);
 677
 678       if (!cstr_array)
 679         cstr_global = nullptr;
 680
 681       if (!RewriteObjCConstString(nsstring_global, cstr_global)) {
 682         LLDB_LOG(log, "Error rewriting the constant string");
 683
 684         // We don't print an error message here because RewriteObjCConstString
 685         // has done so for us.
 686
 687         return false;
 688       }
 689     }
 690   }
 691
 692   for (StringMapEntry<llvm::Value *> &value_symbol : value_symbol_table) {
 693     llvm::StringRef value_name = value_symbol.first();
 694
 695     if (value_name == "__CFConstantStringClassReference") {
 696       GlobalVariable *gv = dyn_cast<GlobalVariable>(value_symbol.second);
 697
 698       if (!gv) {
 699         LLDB_LOG(log,
 700                  "__CFConstantStringClassReference is not a global variable");
 701
 702         m_error_stream.Printf("Internal error [IRForTarget]: Found a "
 703                               "CFConstantStringClassReference, but it is not a "
 704                               "global object\n");
 705
 706         return false;
 707       }
 708
 709       gv->eraseFromParent();
 710
 711       break;
 712     }
 713   }
 714
 715   return true;
 716 }
 717
 718 static bool IsObjCSelectorRef(Value *value) {
 719   GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
 720
 721   return !(
 722       !global_variable || !global_variable->hasName() ||
 723       !global_variable->getName().starts_with("OBJC_SELECTOR_REFERENCES_"));
 724 }
 725
 726 // This function does not report errors; its callers are responsible.
 727 bool IRForTarget::RewriteObjCSelector(Instruction *selector_load) {
 728   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 729
 730   LoadInst *load = dyn_cast<LoadInst>(selector_load);
 731
 732   if (!load)
 733     return false;
 734
 735   // Unpack the message name from the selector.  In LLVM IR, an objc_msgSend
 736   // gets represented as
 737   //
 738   //   %sel = load ptr, ptr @OBJC_SELECTOR_REFERENCES_, align 8
 739   //   call i8 @objc_msgSend(ptr %obj, ptr %sel, ...)
 740   //
 741   // where %obj is the object pointer and %sel is the selector.
 742   //
 743   // @"OBJC_SELECTOR_REFERENCES_" is a pointer to a character array called
 744   // @"\01L_OBJC_METH_VAR_NAME_".
 745   // @"\01L_OBJC_METH_VAR_NAME_" contains the string.
 746
 747   // Find the pointer's initializer and get the string from its target.
 748
 749   GlobalVariable *_objc_selector_references_ =
 750       dyn_cast<GlobalVariable>(load->getPointerOperand());
 751
 752   if (!_objc_selector_references_ ||
 753       !_objc_selector_references_->hasInitializer())
 754     return false;
 755
 756   Constant *osr_initializer = _objc_selector_references_->getInitializer();
 757   if (!osr_initializer)
 758     return false;
 759
 760   // Find the string's initializer (a ConstantArray) and get the string from it
 761
 762   GlobalVariable *_objc_meth_var_name_ =
 763       dyn_cast<GlobalVariable>(osr_initializer);
 764
 765   if (!_objc_meth_var_name_ || !_objc_meth_var_name_->hasInitializer())
 766     return false;
 767
 768   Constant *omvn_initializer = _objc_meth_var_name_->getInitializer();
 769
 770   ConstantDataArray *omvn_initializer_array =
 771       dyn_cast<ConstantDataArray>(omvn_initializer);
 772
 773   if (!omvn_initializer_array->isString())
 774     return false;
 775
 776   std::string omvn_initializer_string =
 777       std::string(omvn_initializer_array->getAsString());
 778
 779   LLDB_LOG(log, "Found Objective-C selector reference \"{0}\"",
 780            omvn_initializer_string);
 781
 782   // Construct a call to sel_registerName
 783
 784   if (!m_sel_registerName) {
 785     lldb::addr_t sel_registerName_addr;
 786
 787     bool missing_weak = false;
 788     static lldb_private::ConstString g_sel_registerName_str("sel_registerName");
 789     sel_registerName_addr = m_execution_unit.FindSymbol(g_sel_registerName_str,
 790                                                         missing_weak);
 791     if (sel_registerName_addr == LLDB_INVALID_ADDRESS || missing_weak)
 792       return false;
 793
 794     LLDB_LOG(log, "Found sel_registerName at {0}", sel_registerName_addr);
 795
 796     // Build the function type: struct objc_selector
 797     // *sel_registerName(uint8_t*)
 798
 799     // The below code would be "more correct," but in actuality what's required
 800     // is uint8_t*
 801     // Type *sel_type = StructType::get(m_module->getContext());
 802     // Type *sel_ptr_type = PointerType::getUnqual(sel_type);
 803     Type *sel_ptr_type = PointerType::getUnqual(m_module->getContext());
 804
 805     Type *type_array[1];
 806
 807     type_array[0] = llvm::PointerType::getUnqual(m_module->getContext());
 808
 809     ArrayRef<Type *> srN_arg_types(type_array, 1);
 810
 811     llvm::FunctionType *srN_type =
 812         FunctionType::get(sel_ptr_type, srN_arg_types, false);
 813
 814     // Build the constant containing the pointer to the function
 815     PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
 816     Constant *srN_addr_int =
 817         ConstantInt::get(m_intptr_ty, sel_registerName_addr, false);
 818     m_sel_registerName = {srN_type,
 819                           ConstantExpr::getIntToPtr(srN_addr_int, srN_ptr_ty)};
 820   }
 821
 822   CallInst *srN_call =
 823       CallInst::Create(m_sel_registerName, _objc_meth_var_name_,
 824                        "sel_registerName", selector_load->getIterator());
 825
 826   // Replace the load with the call in all users
 827
 828   selector_load->replaceAllUsesWith(srN_call);
 829
 830   selector_load->eraseFromParent();
 831
 832   return true;
 833 }
 834
 835 bool IRForTarget::RewriteObjCSelectors(BasicBlock &basic_block) {
 836   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 837
 838   InstrList selector_loads;
 839
 840   for (Instruction &inst : basic_block) {
 841     if (LoadInst *load = dyn_cast<LoadInst>(&inst))
 842       if (IsObjCSelectorRef(load->getPointerOperand()))
 843         selector_loads.push_back(&inst);
 844   }
 845
 846   for (Instruction *inst : selector_loads) {
 847     if (!RewriteObjCSelector(inst)) {
 848       m_error_stream.Printf("Internal error [IRForTarget]: Couldn't change a "
 849                             "static reference to an Objective-C selector to a "
 850                             "dynamic reference\n");
 851
 852       LLDB_LOG(log, "Couldn't rewrite a reference to an Objective-C selector");
 853
 854       return false;
 855     }
 856   }
 857
 858   return true;
 859 }
 860
 861 // This function does not report errors; its callers are responsible.
 862 bool IRForTarget::RewritePersistentAlloc(llvm::Instruction *persistent_alloc) {
 863   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
 864
 865   AllocaInst *alloc = dyn_cast<AllocaInst>(persistent_alloc);
 866
 867   MDNode *alloc_md = alloc->getMetadata("clang.decl.ptr");
 868
 869   if (!alloc_md || !alloc_md->getNumOperands())
 870     return false;
 871
 872   ConstantInt *constant_int =
 873       mdconst::dyn_extract<ConstantInt>(alloc_md->getOperand(0));
 874
 875   if (!constant_int)
 876     return false;
 877
 878   // We attempt to register this as a new persistent variable with the DeclMap.
 879
 880   uintptr_t ptr = constant_int->getZExtValue();
 881
 882   clang::VarDecl *decl = reinterpret_cast<clang::VarDecl *>(ptr);
 883
 884   lldb_private::TypeFromParser result_decl_type(
 885       m_decl_map->GetTypeSystem()->GetType(decl->getType()));
 886
 887   StringRef decl_name(decl->getName());
 888   lldb_private::ConstString persistent_variable_name(decl_name.data(),
 889                                                      decl_name.size());
 890   if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name,
 891                                          result_decl_type, false, false))
 892     return false;
 893
 894   GlobalVariable *persistent_global = new GlobalVariable(
 895       (*m_module), alloc->getType(), false,  /* not constant */
 896       GlobalValue::ExternalLinkage, nullptr, /* no initializer */
 897       alloc->getName().str());
 898
 899   // What we're going to do here is make believe this was a regular old
 900   // external variable.  That means we need to make the metadata valid.
 901
 902   NamedMDNode *named_metadata =
 903       m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
 904
 905   llvm::Metadata *values[2];
 906   values[0] = ConstantAsMetadata::get(persistent_global);
 907   values[1] = ConstantAsMetadata::get(constant_int);
 908
 909   ArrayRef<llvm::Metadata *> value_ref(values, 2);
 910
 911   MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
 912   named_metadata->addOperand(persistent_global_md);
 913
 914   // Now, since the variable is a pointer variable, we will drop in a load of
 915   // that pointer variable.
 916
 917   LoadInst *persistent_load =
 918       new LoadInst(persistent_global->getValueType(), persistent_global, "",
 919                    alloc->getIterator());
 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.starts_with("$") && !alloc_name.starts_with("$__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.starts_with("$")) {
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.starts_with("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                     "",
1346                     llvm::cast<Instruction>(
1347                         entry_instruction_finder.GetValue(function))
1348                         ->getIterator());
1349               });
1350
1351           if (!UnfoldConstant(constant_expr, llvm_function, bit_cast_maker,
1352                               entry_instruction_finder, error_stream))
1353             return false;
1354         } break;
1355         case Instruction::GetElementPtr: {
1356           // GetElementPtrConstantExpr
1357           //   OperandList[0] is base
1358           //   OperandList[1]... are indices
1359
1360           FunctionValueCache get_element_pointer_maker(
1361               [&value_maker, &entry_instruction_finder, old_constant,
1362                constant_expr](llvm::Function *function) -> llvm::Value * {
1363                 auto *gep = cast<llvm::GEPOperator>(constant_expr);
1364                 Value *ptr = gep->getPointerOperand();
1365
1366                 if (ptr == old_constant)
1367                   ptr = value_maker.GetValue(function);
1368
1369                 std::vector<Value *> index_vector;
1370                 for (Value *operand : gep->indices()) {
1371                   if (operand == old_constant)
1372                     operand = value_maker.GetValue(function);
1373
1374                   index_vector.push_back(operand);
1375                 }
1376
1377                 ArrayRef<Value *> indices(index_vector);
1378
1379                 return GetElementPtrInst::Create(
1380                     gep->getSourceElementType(), ptr, indices, "",
1381                     llvm::cast<Instruction>(
1382                         entry_instruction_finder.GetValue(function))
1383                         ->getIterator());
1384               });
1385
1386           if (!UnfoldConstant(constant_expr, llvm_function,
1387                               get_element_pointer_maker,
1388                               entry_instruction_finder, error_stream))
1389             return false;
1390         } break;
1391         }
1392       } else {
1393         error_stream.Printf(
1394             "error [IRForTarget internal]: Unhandled constant type: \"%s\"",
1395             PrintValue(constant).c_str());
1396         return false;
1397       }
1398     } else {
1399       if (Instruction *inst = llvm::dyn_cast<Instruction>(user)) {
1400         if (llvm_function && inst->getParent()->getParent() != llvm_function) {
1401           error_stream.PutCString("error: Capturing non-local variables in "
1402                                   "expressions is unsupported.\n");
1403           return false;
1404         }
1405         inst->replaceUsesOfWith(
1406             old_constant, value_maker.GetValue(inst->getParent()->getParent()));
1407       } else {
1408         error_stream.Printf(
1409             "error [IRForTarget internal]: Unhandled non-constant type: \"%s\"",
1410             PrintValue(user).c_str());
1411         return false;
1412       }
1413     }
1414   }
1415
1416   if (!isa<GlobalValue>(old_constant)) {
1417     old_constant->destroyConstant();
1418   }
1419
1420   return true;
1421 }
1422
1423 bool IRForTarget::ReplaceVariables(Function &llvm_function) {
1424   if (!m_resolve_vars)
1425     return true;
1426
1427   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
1428
1429   m_decl_map->DoStructLayout();
1430
1431   LLDB_LOG(log, "Element arrangement:");
1432
1433   uint32_t num_elements;
1434   uint32_t element_index;
1435
1436   size_t size;
1437   lldb::offset_t alignment;
1438
1439   if (!m_decl_map->GetStructInfo(num_elements, size, alignment))
1440     return false;
1441
1442   Function::arg_iterator iter(llvm_function.arg_begin());
1443
1444   if (iter == llvm_function.arg_end()) {
1445     m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes no "
1446                           "arguments (should take at least a struct pointer)");
1447
1448     return false;
1449   }
1450
1451   Argument *argument = &*iter;
1452
1453   if (argument->getName() == "this") {
1454     ++iter;
1455
1456     if (iter == llvm_function.arg_end()) {
1457       m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1458                             "'this' argument (should take a struct pointer "
1459                             "too)");
1460
1461       return false;
1462     }
1463
1464     argument = &*iter;
1465   } else if (argument->getName() == "self") {
1466     ++iter;
1467
1468     if (iter == llvm_function.arg_end()) {
1469       m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1470                             "'self' argument (should take '_cmd' and a struct "
1471                             "pointer too)");
1472
1473       return false;
1474     }
1475
1476     if (iter->getName() != "_cmd") {
1477       m_error_stream.Format("Internal error [IRForTarget]: Wrapper takes '{0}' "
1478                             "after 'self' argument (should take '_cmd')",
1479                             iter->getName());
1480
1481       return false;
1482     }
1483
1484     ++iter;
1485
1486     if (iter == llvm_function.arg_end()) {
1487       m_error_stream.Printf("Internal error [IRForTarget]: Wrapper takes only "
1488                             "'self' and '_cmd' arguments (should take a struct "
1489                             "pointer too)");
1490
1491       return false;
1492     }
1493
1494     argument = &*iter;
1495   }
1496
1497   if (argument->getName() != "$__lldb_arg") {
1498     m_error_stream.Format("Internal error [IRForTarget]: Wrapper takes an "
1499                           "argument named '{0}' instead of the struct pointer",
1500                           argument->getName());
1501
1502     return false;
1503   }
1504
1505   LLDB_LOG(log, "Arg: \"{0}\"", PrintValue(argument));
1506
1507   BasicBlock &entry_block(llvm_function.getEntryBlock());
1508   Instruction *FirstEntryInstruction(entry_block.getFirstNonPHIOrDbg());
1509
1510   if (!FirstEntryInstruction) {
1511     m_error_stream.Printf("Internal error [IRForTarget]: Couldn't find the "
1512                           "first instruction in the wrapper for use in "
1513                           "rewriting");
1514
1515     return false;
1516   }
1517
1518   LLVMContext &context(m_module->getContext());
1519   IntegerType *offset_type(Type::getInt32Ty(context));
1520
1521   if (!offset_type) {
1522     m_error_stream.Printf(
1523         "Internal error [IRForTarget]: Couldn't produce an offset type");
1524
1525     return false;
1526   }
1527
1528   for (element_index = 0; element_index < num_elements; ++element_index) {
1529     const clang::NamedDecl *decl = nullptr;
1530     Value *value = nullptr;
1531     lldb::offset_t offset;
1532     lldb_private::ConstString name;
1533
1534     if (!m_decl_map->GetStructElement(decl, value, offset, name,
1535                                       element_index)) {
1536       m_error_stream.Printf(
1537           "Internal error [IRForTarget]: Structure information is incomplete");
1538
1539       return false;
1540     }
1541
1542     LLDB_LOG(log, "  \"{0}\" (\"{1}\") placed at {2}", name,
1543              decl->getNameAsString(), offset);
1544
1545     if (value) {
1546       LLDB_LOG(log, "    Replacing [{0}]", PrintValue(value));
1547
1548       FunctionValueCache body_result_maker(
1549           [this, name, offset_type, offset, argument,
1550            value](llvm::Function *function) -> llvm::Value * {
1551             // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
1552             // in cases where the result variable is an rvalue, we have to
1553             // synthesize a dereference of the appropriate structure entry in
1554             // order to produce the static variable that the AST thinks it is
1555             // accessing.
1556
1557             llvm::Instruction *entry_instruction = llvm::cast<Instruction>(
1558                 m_entry_instruction_finder.GetValue(function));
1559
1560             Type *int8Ty = Type::getInt8Ty(function->getContext());
1561             ConstantInt *offset_int(
1562                 ConstantInt::get(offset_type, offset, true));
1563             GetElementPtrInst *get_element_ptr =
1564                 GetElementPtrInst::Create(int8Ty, argument, offset_int, "",
1565                                           entry_instruction->getIterator());
1566
1567             if (name == m_result_name && !m_result_is_pointer) {
1568               LoadInst *load =
1569                   new LoadInst(value->getType(), get_element_ptr, "",
1570                                entry_instruction->getIterator());
1571
1572               return load;
1573             } else {
1574               return get_element_ptr;
1575             }
1576           });
1577
1578       if (Constant *constant = dyn_cast<Constant>(value)) {
1579         if (!UnfoldConstant(constant, &llvm_function, body_result_maker,
1580                             m_entry_instruction_finder, m_error_stream)) {
1581           return false;
1582         }
1583       } else if (Instruction *instruction = dyn_cast<Instruction>(value)) {
1584         if (instruction->getParent()->getParent() != &llvm_function) {
1585           m_error_stream.PutCString("error: Capturing non-local variables in "
1586                                     "expressions is unsupported.\n");
1587           return false;
1588         }
1589         value->replaceAllUsesWith(
1590             body_result_maker.GetValue(instruction->getParent()->getParent()));
1591       } else {
1592         LLDB_LOG(log, "Unhandled non-constant type: \"{0}\"",
1593                  PrintValue(value));
1594         return false;
1595       }
1596
1597       if (GlobalVariable *var = dyn_cast<GlobalVariable>(value))
1598         var->eraseFromParent();
1599     }
1600   }
1601
1602   LLDB_LOG(log, "Total structure [align {0}, size {1}]", (int64_t)alignment,
1603            (uint64_t)size);
1604
1605   return true;
1606 }
1607
1608 bool IRForTarget::runOnModule(Module &llvm_module) {
1609   lldb_private::Log *log(GetLog(LLDBLog::Expressions));
1610
1611   m_module = &llvm_module;
1612   m_target_data = &m_module->getDataLayout();
1613   m_intptr_ty = llvm::Type::getIntNTy(m_module->getContext(),
1614                                       m_target_data->getPointerSizeInBits());
1615
1616   if (log) {
1617     std::string s;
1618     raw_string_ostream oss(s);
1619
1620     m_module->print(oss, nullptr);
1621
1622     LLDB_LOG(log, "Module as passed in to IRForTarget: \n\"{0}\"", s);
1623   }
1624
1625   Function *const main_function =
1626       m_func_name.IsEmpty() ? nullptr
1627                             : m_module->getFunction(m_func_name.GetStringRef());
1628
1629   if (!m_func_name.IsEmpty() && !main_function) {
1630     LLDB_LOG(log, "Couldn't find \"{0}()\" in the module", m_func_name);
1631
1632     m_error_stream.Format("Internal error [IRForTarget]: Couldn't find wrapper "
1633                           "'{0}' in the module",
1634                           m_func_name);
1635
1636     return false;
1637   }
1638
1639   if (main_function) {
1640     if (!FixFunctionLinkage(*main_function)) {
1641       LLDB_LOG(log, "Couldn't fix the linkage for the function");
1642
1643       return false;
1644     }
1645   }
1646
1647   ////////////////////////////////////////////////////////////
1648   // Replace $__lldb_expr_result with a persistent variable
1649   //
1650
1651   if (main_function) {
1652     if (!CreateResultVariable(*main_function)) {
1653       LLDB_LOG(log, "CreateResultVariable() failed");
1654
1655       // CreateResultVariable() reports its own errors, so we don't do so here
1656
1657       return false;
1658     }
1659   }
1660
1661   if (log && log->GetVerbose()) {
1662     std::string s;
1663     raw_string_ostream oss(s);
1664
1665     m_module->print(oss, nullptr);
1666
1667     LLDB_LOG(log, "Module after creating the result variable: \n\"{0}\"", s);
1668   }
1669
1670   for (llvm::Function &function : *m_module) {
1671     for (BasicBlock &bb : function) {
1672       if (!RemoveGuards(bb)) {
1673         LLDB_LOG(log, "RemoveGuards() failed");
1674
1675         // RemoveGuards() reports its own errors, so we don't do so here
1676
1677         return false;
1678       }
1679
1680       if (!RewritePersistentAllocs(bb)) {
1681         LLDB_LOG(log, "RewritePersistentAllocs() failed");
1682
1683         // RewritePersistentAllocs() reports its own errors, so we don't do so
1684         // here
1685
1686         return false;
1687       }
1688
1689       if (!RemoveCXAAtExit(bb)) {
1690         LLDB_LOG(log, "RemoveCXAAtExit() failed");
1691
1692         // RemoveCXAAtExit() reports its own errors, so we don't do so here
1693
1694         return false;
1695       }
1696     }
1697   }
1698
1699   ///////////////////////////////////////////////////////////////////////////////
1700   // Fix all Objective-C constant strings to use NSStringWithCString:encoding:
1701   //
1702
1703   if (!RewriteObjCConstStrings()) {
1704     LLDB_LOG(log, "RewriteObjCConstStrings() failed");
1705
1706     // RewriteObjCConstStrings() reports its own errors, so we don't do so here
1707
1708     return false;
1709   }
1710
1711   for (llvm::Function &function : *m_module) {
1712     for (llvm::BasicBlock &bb : function) {
1713       if (!RewriteObjCSelectors(bb)) {
1714         LLDB_LOG(log, "RewriteObjCSelectors() failed");
1715
1716         // RewriteObjCSelectors() reports its own errors, so we don't do so
1717         // here
1718
1719         return false;
1720       }
1721     }
1722   }
1723
1724   for (llvm::Function &function : *m_module) {
1725     for (BasicBlock &bb : function) {
1726       if (!ResolveCalls(bb)) {
1727         LLDB_LOG(log, "ResolveCalls() failed");
1728
1729         // ResolveCalls() reports its own errors, so we don't do so here
1730
1731         return false;
1732       }
1733     }
1734   }
1735
1736   ////////////////////////////////////////////////////////////////////////
1737   // Run function-level passes that only make sense on the main function
1738   //
1739
1740   if (main_function) {
1741     if (!ResolveExternals(*main_function)) {
1742       LLDB_LOG(log, "ResolveExternals() failed");
1743
1744       // ResolveExternals() reports its own errors, so we don't do so here
1745
1746       return false;
1747     }
1748
1749     if (!ReplaceVariables(*main_function)) {
1750       LLDB_LOG(log, "ReplaceVariables() failed");
1751
1752       // ReplaceVariables() reports its own errors, so we don't do so here
1753
1754       return false;
1755     }
1756   }
1757
1758   if (log && log->GetVerbose()) {
1759     std::string s;
1760     raw_string_ostream oss(s);
1761
1762     m_module->print(oss, nullptr);
1763
1764     LLDB_LOG(log, "Module after preparing for execution: \n\"{0}\"", s);
1765   }
1766
1767   return true;
1768 }