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