contrib/llvm/tools/lldb/source/Expression/IRForTarget.cpp

   1 //===-- IRForTarget.cpp -----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Expression/IRForTarget.h"
  11
  12 #include "llvm/Support/raw_ostream.h"
  13 #include "llvm/IR/Constants.h"
  14 #include "llvm/IR/DataLayout.h"
  15 #include "llvm/IR/InstrTypes.h"
  16 #include "llvm/IR/Instructions.h"
  17 #include "llvm/IR/Intrinsics.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/PassManager.h"
  20 #include "llvm/Transforms/IPO.h"
  21 #include "llvm/IR/ValueSymbolTable.h"
  22
  23 #include "clang/AST/ASTContext.h"
  24
  25 #include "lldb/Core/dwarf.h"
  26 #include "lldb/Core/ConstString.h"
  27 #include "lldb/Core/DataBufferHeap.h"
  28 #include "lldb/Core/Log.h"
  29 #include "lldb/Core/Scalar.h"
  30 #include "lldb/Core/StreamString.h"
  31 #include "lldb/Expression/ClangExpressionDeclMap.h"
  32 #include "lldb/Expression/IRExecutionUnit.h"
  33 #include "lldb/Expression/IRInterpreter.h"
  34 #include "lldb/Host/Endian.h"
  35 #include "lldb/Symbol/ClangASTContext.h"
  36 #include "lldb/Symbol/ClangASTType.h"
  37
  38 #include <map>
  39
  40 using namespace llvm;
  41
  42 static char ID;
  43
  44 IRForTarget::StaticDataAllocator::StaticDataAllocator(lldb_private::IRExecutionUnit &execution_unit) :
  45     m_execution_unit(execution_unit),
  46     m_stream_string(lldb_private::Stream::eBinary, execution_unit.GetAddressByteSize(), execution_unit.GetByteOrder()),
  47     m_allocation(LLDB_INVALID_ADDRESS)
  48 {
  49 }
  50
  51 IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker) :
  52     m_maker(maker),
  53     m_values()
  54 {
  55 }
  56
  57 IRForTarget::FunctionValueCache::~FunctionValueCache()
  58 {
  59 }
  60
  61 llvm::Value *IRForTarget::FunctionValueCache::GetValue(llvm::Function *function)
  62 {
  63     if (!m_values.count(function))
  64     {
  65         llvm::Value *ret = m_maker(function);
  66         m_values[function] = ret;
  67         return ret;
  68     }
  69     return m_values[function];
  70 }
  71
  72 lldb::addr_t IRForTarget::StaticDataAllocator::Allocate()
  73 {
  74     lldb_private::Error err;
  75
  76     if (m_allocation != LLDB_INVALID_ADDRESS)
  77     {
  78         m_execution_unit.FreeNow(m_allocation);
  79         m_allocation = LLDB_INVALID_ADDRESS;
  80     }
  81
  82     m_allocation = m_execution_unit.WriteNow((const uint8_t*)m_stream_string.GetData(), m_stream_string.GetSize(), err);
  83
  84     return m_allocation;
  85 }
  86
  87 static llvm::Value *FindEntryInstruction (llvm::Function *function)
  88 {
  89     if (function->empty())
  90         return NULL;
  91
  92     return function->getEntryBlock().getFirstNonPHIOrDbg();
  93 }
  94
  95 IRForTarget::IRForTarget (lldb_private::ClangExpressionDeclMap *decl_map,
  96                           bool resolve_vars,
  97                           lldb_private::IRExecutionUnit &execution_unit,
  98                           lldb_private::Stream *error_stream,
  99                           const char *func_name) :
 100     ModulePass(ID),
 101     m_resolve_vars(resolve_vars),
 102     m_func_name(func_name),
 103     m_module(NULL),
 104     m_decl_map(decl_map),
 105     m_data_allocator(execution_unit),
 106     m_CFStringCreateWithBytes(NULL),
 107     m_sel_registerName(NULL),
 108     m_error_stream(error_stream),
 109     m_result_store(NULL),
 110     m_result_is_pointer(false),
 111     m_reloc_placeholder(NULL),
 112     m_entry_instruction_finder (FindEntryInstruction)
 113 {
 114 }
 115
 116 /* Handy utility functions used at several places in the code */
 117
 118 static std::string
 119 PrintValue(const Value *value, bool truncate = false)
 120 {
 121     std::string s;
 122     if (value)
 123     {
 124         raw_string_ostream rso(s);
 125         value->print(rso);
 126         rso.flush();
 127         if (truncate)
 128             s.resize(s.length() - 1);
 129     }
 130     return s;
 131 }
 132
 133 static std::string
 134 PrintType(const llvm::Type *type, bool truncate = false)
 135 {
 136     std::string s;
 137     raw_string_ostream rso(s);
 138     type->print(rso);
 139     rso.flush();
 140     if (truncate)
 141         s.resize(s.length() - 1);
 142     return s;
 143 }
 144
 145 IRForTarget::~IRForTarget()
 146 {
 147 }
 148
 149 bool
 150 IRForTarget::FixFunctionLinkage(llvm::Function &llvm_function)
 151 {
 152     llvm_function.setLinkage(GlobalValue::ExternalLinkage);
 153
 154     std::string name = llvm_function.getName().str();
 155
 156     return true;
 157 }
 158
 159 bool
 160 IRForTarget::GetFunctionAddress (llvm::Function *fun,
 161                                  uint64_t &fun_addr,
 162                                  lldb_private::ConstString &name,
 163                                  Constant **&value_ptr)
 164 {
 165     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 166
 167     fun_addr = LLDB_INVALID_ADDRESS;
 168     name.Clear();
 169     value_ptr = NULL;
 170
 171     if (fun->isIntrinsic())
 172     {
 173         Intrinsic::ID intrinsic_id = (Intrinsic::ID)fun->getIntrinsicID();
 174
 175         switch (intrinsic_id)
 176         {
 177         default:
 178             if (log)
 179                 log->Printf("Unresolved intrinsic \"%s\"", Intrinsic::getName(intrinsic_id).c_str());
 180
 181             if (m_error_stream)
 182                 m_error_stream->Printf("Internal error [IRForTarget]: Call to unhandled compiler intrinsic '%s'\n", Intrinsic::getName(intrinsic_id).c_str());
 183
 184             return false;
 185         case Intrinsic::memcpy:
 186             {
 187                 static lldb_private::ConstString g_memcpy_str ("memcpy");
 188                 name = g_memcpy_str;
 189             }
 190             break;
 191         case Intrinsic::memset:
 192             {
 193                 static lldb_private::ConstString g_memset_str ("memset");
 194                 name = g_memset_str;
 195             }
 196             break;
 197         }
 198
 199         if (log && name)
 200             log->Printf("Resolved intrinsic name \"%s\"", name.GetCString());
 201     }
 202     else
 203     {
 204         name.SetCStringWithLength (fun->getName().data(), fun->getName().size());
 205     }
 206
 207     // Find the address of the function.
 208
 209     clang::NamedDecl *fun_decl = DeclForGlobal (fun);
 210
 211     if (fun_decl)
 212     {
 213         if (!m_decl_map->GetFunctionInfo (fun_decl, fun_addr))
 214         {
 215             lldb_private::ConstString altnernate_name;
 216             bool found_it = m_decl_map->GetFunctionAddress (name, fun_addr);
 217             if (!found_it)
 218             {
 219                 // Check for an alternate mangling for "std::basic_string<char>"
 220                 // that is part of the itanium C++ name mangling scheme
 221                 const char *name_cstr = name.GetCString();
 222                 if (name_cstr && strncmp(name_cstr, "_ZNKSbIcE", strlen("_ZNKSbIcE")) == 0)
 223                 {
 224                     std::string alternate_mangling("_ZNKSs");
 225                     alternate_mangling.append (name_cstr + strlen("_ZNKSbIcE"));
 226                     altnernate_name.SetCString(alternate_mangling.c_str());
 227                     found_it = m_decl_map->GetFunctionAddress (altnernate_name, fun_addr);
 228                 }
 229             }
 230
 231             if (!found_it)
 232             {
 233                 lldb_private::Mangled mangled_name(name);
 234                 lldb_private::Mangled alt_mangled_name(altnernate_name);
 235                 if (log)
 236                 {
 237                     if (alt_mangled_name)
 238                         log->Printf("Function \"%s\" (alternate name \"%s\") has no address",
 239                                     mangled_name.GetName().GetCString(),
 240                                     alt_mangled_name.GetName().GetCString());
 241                     else
 242                         log->Printf("Function \"%s\" had no address",
 243                                     mangled_name.GetName().GetCString());
 244                 }
 245
 246                 if (m_error_stream)
 247                 {
 248                     if (alt_mangled_name)
 249                         m_error_stream->Printf("error: call to a function '%s' (alternate name '%s') that is not present in the target\n",
 250                                                mangled_name.GetName().GetCString(),
 251                                                alt_mangled_name.GetName().GetCString());
 252                     else if (mangled_name.GetMangledName())
 253                         m_error_stream->Printf("error: call to a function '%s' ('%s') that is not present in the target\n",
 254                                                mangled_name.GetName().GetCString(),
 255                                                mangled_name.GetMangledName().GetCString());
 256                     else
 257                         m_error_stream->Printf("error: call to a function '%s' that is not present in the target\n",
 258                                                mangled_name.GetName().GetCString());
 259                 }
 260                 return false;
 261             }
 262         }
 263     }
 264     else
 265     {
 266         if (!m_decl_map->GetFunctionAddress (name, fun_addr))
 267         {
 268             if (log)
 269                 log->Printf ("Metadataless function \"%s\" had no address", name.GetCString());
 270
 271             if (m_error_stream)
 272                 m_error_stream->Printf("Error [IRForTarget]: Call to a symbol-only function '%s' that is not present in the target\n", name.GetCString());
 273
 274             return false;
 275         }
 276     }
 277
 278     if (log)
 279         log->Printf("Found \"%s\" at 0x%" PRIx64, name.GetCString(), fun_addr);
 280
 281     return true;
 282 }
 283
 284 llvm::Constant *
 285 IRForTarget::BuildFunctionPointer (llvm::Type *type,
 286                                    uint64_t ptr)
 287 {
 288     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
 289                                              (m_module->getPointerSize() == Module::Pointer64) ? 64 : 32);
 290     PointerType *fun_ptr_ty = PointerType::getUnqual(type);
 291     Constant *fun_addr_int = ConstantInt::get(intptr_ty, ptr, false);
 292     return ConstantExpr::getIntToPtr(fun_addr_int, fun_ptr_ty);
 293 }
 294
 295 void
 296 IRForTarget::RegisterFunctionMetadata(LLVMContext &context,
 297                                       llvm::Value *function_ptr,
 298                                       const char *name)
 299 {
 300     for (Value::use_iterator i = function_ptr->use_begin(), e = function_ptr->use_end();
 301          i != e;
 302          ++i)
 303     {
 304         Value *user = *i;
 305
 306         if (Instruction *user_inst = dyn_cast<Instruction>(user))
 307         {
 308             MDString* md_name = MDString::get(context, StringRef(name));
 309
 310             MDNode *metadata = MDNode::get(context, md_name);
 311
 312             user_inst->setMetadata("lldb.call.realName", metadata);
 313         }
 314         else
 315         {
 316             RegisterFunctionMetadata (context, user, name);
 317         }
 318     }
 319 }
 320
 321 bool
 322 IRForTarget::ResolveFunctionPointers(llvm::Module &llvm_module)
 323 {
 324     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 325
 326     for (llvm::Module::iterator fi = llvm_module.begin();
 327          fi != llvm_module.end();
 328          ++fi)
 329     {
 330         Function *fun = fi;
 331
 332         bool is_decl = fun->isDeclaration();
 333
 334         if (log)
 335             log->Printf("Examining %s function %s", (is_decl ? "declaration" : "non-declaration"), fun->getName().str().c_str());
 336
 337         if (!is_decl)
 338             continue;
 339
 340         if (fun->hasNUses(0))
 341             continue; // ignore
 342
 343         uint64_t addr = LLDB_INVALID_ADDRESS;
 344         lldb_private::ConstString name;
 345         Constant **value_ptr = NULL;
 346
 347         if (!GetFunctionAddress(fun,
 348                                 addr,
 349                                 name,
 350                                 value_ptr))
 351             return false; // GetFunctionAddress reports its own errors
 352
 353         Constant *value = BuildFunctionPointer(fun->getFunctionType(), addr);
 354
 355         RegisterFunctionMetadata (llvm_module.getContext(), fun, name.AsCString());
 356
 357         if (value_ptr)
 358             *value_ptr = value;
 359
 360         // If we are replacing a function with the nobuiltin attribute, it may
 361         // be called with the builtin attribute on call sites. Remove any such
 362         // attributes since it's illegal to have a builtin call to something
 363         // other than a nobuiltin function.
 364         if (fun->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
 365             llvm::Attribute builtin = llvm::Attribute::get(fun->getContext(), llvm::Attribute::Builtin);
 366
 367             for (auto u = fun->use_begin(), e = fun->use_end(); u != e; ++u) {
 368                 if (auto call = dyn_cast<CallInst>(*u)) {
 369                     call->removeAttribute(AttributeSet::FunctionIndex, builtin);
 370                 }
 371             }
 372         }
 373
 374         fun->replaceAllUsesWith(value);
 375     }
 376
 377     return true;
 378 }
 379
 380
 381 clang::NamedDecl *
 382 IRForTarget::DeclForGlobal (const GlobalValue *global_val, Module *module)
 383 {
 384     NamedMDNode *named_metadata = module->getNamedMetadata("clang.global.decl.ptrs");
 385
 386     if (!named_metadata)
 387         return NULL;
 388
 389     unsigned num_nodes = named_metadata->getNumOperands();
 390     unsigned node_index;
 391
 392     for (node_index = 0;
 393          node_index < num_nodes;
 394          ++node_index)
 395     {
 396         MDNode *metadata_node = named_metadata->getOperand(node_index);
 397
 398         if (!metadata_node)
 399             return NULL;
 400
 401         if (metadata_node->getNumOperands() != 2)
 402             continue;
 403
 404         if (metadata_node->getOperand(0) != global_val)
 405             continue;
 406
 407         ConstantInt *constant_int = dyn_cast<ConstantInt>(metadata_node->getOperand(1));
 408
 409         if (!constant_int)
 410             return NULL;
 411
 412         uintptr_t ptr = constant_int->getZExtValue();
 413
 414         return reinterpret_cast<clang::NamedDecl *>(ptr);
 415     }
 416
 417     return NULL;
 418 }
 419
 420 clang::NamedDecl *
 421 IRForTarget::DeclForGlobal (GlobalValue *global_val)
 422 {
 423     return DeclForGlobal(global_val, m_module);
 424 }
 425
 426 bool
 427 IRForTarget::CreateResultVariable (llvm::Function &llvm_function)
 428 {
 429     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 430
 431     if (!m_resolve_vars)
 432         return true;
 433
 434     // Find the result variable.  If it doesn't exist, we can give up right here.
 435
 436     ValueSymbolTable& value_symbol_table = m_module->getValueSymbolTable();
 437
 438     std::string result_name_str;
 439     const char *result_name = NULL;
 440
 441     for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
 442          vi != ve;
 443          ++vi)
 444     {
 445         result_name_str = vi->first().str();
 446         const char *value_name = result_name_str.c_str();
 447
 448         if (strstr(value_name, "$__lldb_expr_result_ptr") &&
 449             strncmp(value_name, "_ZGV", 4))
 450         {
 451             result_name = value_name;
 452             m_result_is_pointer = true;
 453             break;
 454         }
 455
 456         if (strstr(value_name, "$__lldb_expr_result") &&
 457             strncmp(value_name, "_ZGV", 4))
 458         {
 459             result_name = value_name;
 460             m_result_is_pointer = false;
 461             break;
 462         }
 463     }
 464
 465     if (!result_name)
 466     {
 467         if (log)
 468             log->PutCString("Couldn't find result variable");
 469
 470         return true;
 471     }
 472
 473     if (log)
 474         log->Printf("Result name: \"%s\"", result_name);
 475
 476     Value *result_value = m_module->getNamedValue(result_name);
 477
 478     if (!result_value)
 479     {
 480         if (log)
 481             log->PutCString("Result variable had no data");
 482
 483         if (m_error_stream)
 484             m_error_stream->Printf("Internal error [IRForTarget]: Result variable's name (%s) exists, but not its definition\n", result_name);
 485
 486         return false;
 487     }
 488
 489     if (log)
 490         log->Printf("Found result in the IR: \"%s\"", PrintValue(result_value, false).c_str());
 491
 492     GlobalVariable *result_global = dyn_cast<GlobalVariable>(result_value);
 493
 494     if (!result_global)
 495     {
 496         if (log)
 497             log->PutCString("Result variable isn't a GlobalVariable");
 498
 499         if (m_error_stream)
 500             m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) is defined, but is not a global variable\n", result_name);
 501
 502         return false;
 503     }
 504
 505     clang::NamedDecl *result_decl = DeclForGlobal (result_global);
 506     if (!result_decl)
 507     {
 508         if (log)
 509             log->PutCString("Result variable doesn't have a corresponding Decl");
 510
 511         if (m_error_stream)
 512             m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) does not have a corresponding Clang entity\n", result_name);
 513
 514         return false;
 515     }
 516
 517     if (log)
 518     {
 519         std::string decl_desc_str;
 520         raw_string_ostream decl_desc_stream(decl_desc_str);
 521         result_decl->print(decl_desc_stream);
 522         decl_desc_stream.flush();
 523
 524         log->Printf("Found result decl: \"%s\"", decl_desc_str.c_str());
 525     }
 526
 527     clang::VarDecl *result_var = dyn_cast<clang::VarDecl>(result_decl);
 528     if (!result_var)
 529     {
 530         if (log)
 531             log->PutCString("Result variable Decl isn't a VarDecl");
 532
 533         if (m_error_stream)
 534             m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s)'s corresponding Clang entity isn't a variable\n", result_name);
 535
 536         return false;
 537     }
 538
 539     // Get the next available result name from m_decl_map and create the persistent
 540     // variable for it
 541
 542     // If the result is an Lvalue, it is emitted as a pointer; see
 543     // ASTResultSynthesizer::SynthesizeBodyResult.
 544     if (m_result_is_pointer)
 545     {
 546         clang::QualType pointer_qual_type = result_var->getType();
 547         const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
 548
 549         const clang::PointerType *pointer_pointertype = pointer_type->getAs<clang::PointerType>();
 550         const clang::ObjCObjectPointerType *pointer_objcobjpointertype = pointer_type->getAs<clang::ObjCObjectPointerType>();
 551
 552         if (pointer_pointertype)
 553         {
 554             clang::QualType element_qual_type = pointer_pointertype->getPointeeType();
 555
 556             m_result_type = lldb_private::TypeFromParser(element_qual_type.getAsOpaquePtr(),
 557                                                          &result_decl->getASTContext());
 558         }
 559         else if (pointer_objcobjpointertype)
 560         {
 561             clang::QualType element_qual_type = clang::QualType(pointer_objcobjpointertype->getObjectType(), 0);
 562
 563             m_result_type = lldb_private::TypeFromParser(element_qual_type.getAsOpaquePtr(),
 564                                                          &result_decl->getASTContext());
 565         }
 566         else
 567         {
 568             if (log)
 569                 log->PutCString("Expected result to have pointer type, but it did not");
 570
 571             if (m_error_stream)
 572                 m_error_stream->Printf("Internal error [IRForTarget]: Lvalue result (%s) is not a pointer variable\n", result_name);
 573
 574             return false;
 575         }
 576     }
 577     else
 578     {
 579         m_result_type = lldb_private::TypeFromParser(result_var->getType().getAsOpaquePtr(),
 580                                                      &result_decl->getASTContext());
 581     }
 582
 583     if (m_result_type.GetBitSize() == 0)
 584     {
 585         lldb_private::StreamString type_desc_stream;
 586         m_result_type.DumpTypeDescription(&type_desc_stream);
 587
 588         if (log)
 589             log->Printf("Result type has size 0");
 590
 591         if (m_error_stream)
 592             m_error_stream->Printf("Error [IRForTarget]: Size of result type '%s' couldn't be determined\n",
 593                                    type_desc_stream.GetData());
 594         return false;
 595     }
 596
 597     if (log)
 598     {
 599         lldb_private::StreamString type_desc_stream;
 600         m_result_type.DumpTypeDescription(&type_desc_stream);
 601
 602         log->Printf("Result decl type: \"%s\"", type_desc_stream.GetData());
 603     }
 604
 605     m_result_name = lldb_private::ConstString("$RESULT_NAME");
 606
 607     if (log)
 608         log->Printf("Creating a new result global: \"%s\" with size 0x%" PRIx64,
 609                     m_result_name.GetCString(),
 610                     m_result_type.GetByteSize());
 611
 612     // Construct a new result global and set up its metadata
 613
 614     GlobalVariable *new_result_global = new GlobalVariable((*m_module),
 615                                                            result_global->getType()->getElementType(),
 616                                                            false, /* not constant */
 617                                                            GlobalValue::ExternalLinkage,
 618                                                            NULL, /* no initializer */
 619                                                            m_result_name.GetCString ());
 620
 621     // It's too late in compilation to create a new VarDecl for this, but we don't
 622     // need to.  We point the metadata at the old VarDecl.  This creates an odd
 623     // anomaly: a variable with a Value whose name is something like $0 and a
 624     // Decl whose name is $__lldb_expr_result.  This condition is handled in
 625     // ClangExpressionDeclMap::DoMaterialize, and the name of the variable is
 626     // fixed up.
 627
 628     ConstantInt *new_constant_int = ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
 629                                                      reinterpret_cast<uint64_t>(result_decl),
 630                                                      false);
 631
 632     llvm::Value* values[2];
 633     values[0] = new_result_global;
 634     values[1] = new_constant_int;
 635
 636     ArrayRef<Value*> value_ref(values, 2);
 637
 638     MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
 639     NamedMDNode *named_metadata = m_module->getNamedMetadata("clang.global.decl.ptrs");
 640     named_metadata->addOperand(persistent_global_md);
 641
 642     if (log)
 643         log->Printf("Replacing \"%s\" with \"%s\"",
 644                     PrintValue(result_global).c_str(),
 645                     PrintValue(new_result_global).c_str());
 646
 647     if (result_global->hasNUses(0))
 648     {
 649         // We need to synthesize a store for this variable, because otherwise
 650         // there's nothing to put into its equivalent persistent variable.
 651
 652         BasicBlock &entry_block(llvm_function.getEntryBlock());
 653         Instruction *first_entry_instruction(entry_block.getFirstNonPHIOrDbg());
 654
 655         if (!first_entry_instruction)
 656             return false;
 657
 658         if (!result_global->hasInitializer())
 659         {
 660             if (log)
 661                 log->Printf("Couldn't find initializer for unused variable");
 662
 663             if (m_error_stream)
 664                 m_error_stream->Printf("Internal error [IRForTarget]: Result variable (%s) has no writes and no initializer\n", result_name);
 665
 666             return false;
 667         }
 668
 669         Constant *initializer = result_global->getInitializer();
 670
 671         StoreInst *synthesized_store = new StoreInst(initializer,
 672                                                      new_result_global,
 673                                                      first_entry_instruction);
 674
 675         if (log)
 676             log->Printf("Synthesized result store \"%s\"\n", PrintValue(synthesized_store).c_str());
 677     }
 678     else
 679     {
 680         result_global->replaceAllUsesWith(new_result_global);
 681     }
 682
 683     if (!m_decl_map->AddPersistentVariable(result_decl,
 684                                            m_result_name,
 685                                            m_result_type,
 686                                            true,
 687                                            m_result_is_pointer))
 688         return false;
 689
 690     result_global->eraseFromParent();
 691
 692     return true;
 693 }
 694
 695 #if 0
 696 static void DebugUsers(Log *log, Value *value, uint8_t depth)
 697 {
 698     if (!depth)
 699         return;
 700
 701     depth--;
 702
 703     if (log)
 704         log->Printf("  <Begin %d users>", value->getNumUses());
 705
 706     for (Value::use_iterator ui = value->use_begin(), ue = value->use_end();
 707          ui != ue;
 708          ++ui)
 709     {
 710         if (log)
 711             log->Printf("  <Use %p> %s", *ui, PrintValue(*ui).c_str());
 712         DebugUsers(log, *ui, depth);
 713     }
 714
 715     if (log)
 716         log->Printf("  <End uses>");
 717 }
 718 #endif
 719
 720 bool
 721 IRForTarget::RewriteObjCConstString (llvm::GlobalVariable *ns_str,
 722                                      llvm::GlobalVariable *cstr)
 723 {
 724     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 725
 726     Type *ns_str_ty = ns_str->getType();
 727
 728     Type *i8_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
 729     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
 730                                                    (m_module->getPointerSize()
 731                                                     == Module::Pointer64) ? 64 : 32);
 732     Type *i32_ty = Type::getInt32Ty(m_module->getContext());
 733     Type *i8_ty = Type::getInt8Ty(m_module->getContext());
 734
 735     if (!m_CFStringCreateWithBytes)
 736     {
 737         lldb::addr_t CFStringCreateWithBytes_addr;
 738
 739         static lldb_private::ConstString g_CFStringCreateWithBytes_str ("CFStringCreateWithBytes");
 740
 741         if (!m_decl_map->GetFunctionAddress (g_CFStringCreateWithBytes_str, CFStringCreateWithBytes_addr))
 742         {
 743             if (log)
 744                 log->PutCString("Couldn't find CFStringCreateWithBytes in the target");
 745
 746             if (m_error_stream)
 747                 m_error_stream->Printf("Error [IRForTarget]: Rewriting an Objective-C constant string requires CFStringCreateWithBytes\n");
 748
 749             return false;
 750         }
 751
 752         if (log)
 753             log->Printf("Found CFStringCreateWithBytes at 0x%" PRIx64, CFStringCreateWithBytes_addr);
 754
 755         // Build the function type:
 756         //
 757         // CFStringRef CFStringCreateWithBytes (
 758         //   CFAllocatorRef alloc,
 759         //   const UInt8 *bytes,
 760         //   CFIndex numBytes,
 761         //   CFStringEncoding encoding,
 762         //   Boolean isExternalRepresentation
 763         // );
 764         //
 765         // We make the following substitutions:
 766         //
 767         // CFStringRef -> i8*
 768         // CFAllocatorRef -> i8*
 769         // UInt8 * -> i8*
 770         // CFIndex -> long (i32 or i64, as appropriate; we ask the module for its pointer size for now)
 771         // CFStringEncoding -> i32
 772         // Boolean -> i8
 773
 774         Type *arg_type_array[5];
 775
 776         arg_type_array[0] = i8_ptr_ty;
 777         arg_type_array[1] = i8_ptr_ty;
 778         arg_type_array[2] = intptr_ty;
 779         arg_type_array[3] = i32_ty;
 780         arg_type_array[4] = i8_ty;
 781
 782         ArrayRef<Type *> CFSCWB_arg_types(arg_type_array, 5);
 783
 784         llvm::Type *CFSCWB_ty = FunctionType::get(ns_str_ty, CFSCWB_arg_types, false);
 785
 786         // Build the constant containing the pointer to the function
 787         PointerType *CFSCWB_ptr_ty = PointerType::getUnqual(CFSCWB_ty);
 788         Constant *CFSCWB_addr_int = ConstantInt::get(intptr_ty, CFStringCreateWithBytes_addr, false);
 789         m_CFStringCreateWithBytes = ConstantExpr::getIntToPtr(CFSCWB_addr_int, CFSCWB_ptr_ty);
 790     }
 791
 792     ConstantDataSequential *string_array = NULL;
 793
 794     if (cstr)
 795         string_array = dyn_cast<ConstantDataSequential>(cstr->getInitializer());
 796
 797     Constant *alloc_arg         = Constant::getNullValue(i8_ptr_ty);
 798     Constant *bytes_arg         = cstr ? ConstantExpr::getBitCast(cstr, i8_ptr_ty) : Constant::getNullValue(i8_ptr_ty);
 799     Constant *numBytes_arg      = ConstantInt::get(intptr_ty, cstr ? string_array->getNumElements() - 1 : 0, false);
 800     Constant *encoding_arg      = ConstantInt::get(i32_ty, 0x0600, false); /* 0x0600 is kCFStringEncodingASCII */
 801     Constant *isExternal_arg    = ConstantInt::get(i8_ty, 0x0, false); /* 0x0 is false */
 802
 803     Value *argument_array[5];
 804
 805     argument_array[0] = alloc_arg;
 806     argument_array[1] = bytes_arg;
 807     argument_array[2] = numBytes_arg;
 808     argument_array[3] = encoding_arg;
 809     argument_array[4] = isExternal_arg;
 810
 811     ArrayRef <Value *> CFSCWB_arguments(argument_array, 5);
 812
 813     FunctionValueCache CFSCWB_Caller ([this, &CFSCWB_arguments] (llvm::Function *function)->llvm::Value * {
 814         return CallInst::Create(m_CFStringCreateWithBytes,
 815                                 CFSCWB_arguments,
 816                                 "CFStringCreateWithBytes",
 817                                 llvm::cast<Instruction>(m_entry_instruction_finder.GetValue(function)));
 818     });
 819
 820     if (!UnfoldConstant(ns_str, CFSCWB_Caller, m_entry_instruction_finder))
 821     {
 822         if (log)
 823             log->PutCString("Couldn't replace the NSString with the result of the call");
 824
 825         if (m_error_stream)
 826             m_error_stream->Printf("Error [IRForTarget]: Couldn't replace an Objective-C constant string with a dynamic string\n");
 827
 828         return false;
 829     }
 830
 831     ns_str->eraseFromParent();
 832
 833     return true;
 834 }
 835
 836 bool
 837 IRForTarget::RewriteObjCConstStrings()
 838 {
 839     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 840
 841     ValueSymbolTable& value_symbol_table = m_module->getValueSymbolTable();
 842
 843     for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
 844          vi != ve;
 845          ++vi)
 846     {
 847         std::string value_name = vi->first().str();
 848         const char *value_name_cstr = value_name.c_str();
 849
 850         if (strstr(value_name_cstr, "_unnamed_cfstring_"))
 851         {
 852             Value *nsstring_value = vi->second;
 853
 854             GlobalVariable *nsstring_global = dyn_cast<GlobalVariable>(nsstring_value);
 855
 856             if (!nsstring_global)
 857             {
 858                 if (log)
 859                     log->PutCString("NSString variable is not a GlobalVariable");
 860
 861                 if (m_error_stream)
 862                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string is not a global variable\n");
 863
 864                 return false;
 865             }
 866
 867             if (!nsstring_global->hasInitializer())
 868             {
 869                 if (log)
 870                     log->PutCString("NSString variable does not have an initializer");
 871
 872                 if (m_error_stream)
 873                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string does not have an initializer\n");
 874
 875                 return false;
 876             }
 877
 878             ConstantStruct *nsstring_struct = dyn_cast<ConstantStruct>(nsstring_global->getInitializer());
 879
 880             if (!nsstring_struct)
 881             {
 882                 if (log)
 883                     log->PutCString("NSString variable's initializer is not a ConstantStruct");
 884
 885                 if (m_error_stream)
 886                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string is not a structure constant\n");
 887
 888                 return false;
 889             }
 890
 891             // We expect the following structure:
 892             //
 893             // struct {
 894             //   int *isa;
 895             //   int flags;
 896             //   char *str;
 897             //   long length;
 898             // };
 899
 900             if (nsstring_struct->getNumOperands() != 4)
 901             {
 902                 if (log)
 903                     log->Printf("NSString variable's initializer structure has an unexpected number of members.  Should be 4, is %d", nsstring_struct->getNumOperands());
 904
 905                 if (m_error_stream)
 906                     m_error_stream->Printf("Internal error [IRForTarget]: The struct for an Objective-C constant string is not as expected\n");
 907
 908                 return false;
 909             }
 910
 911             Constant *nsstring_member = nsstring_struct->getOperand(2);
 912
 913             if (!nsstring_member)
 914             {
 915                 if (log)
 916                     log->PutCString("NSString initializer's str element was empty");
 917
 918                 if (m_error_stream)
 919                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string does not have a string initializer\n");
 920
 921                 return false;
 922             }
 923
 924             ConstantExpr *nsstring_expr = dyn_cast<ConstantExpr>(nsstring_member);
 925
 926             if (!nsstring_expr)
 927             {
 928                 if (log)
 929                     log->PutCString("NSString initializer's str element is not a ConstantExpr");
 930
 931                 if (m_error_stream)
 932                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer is not constant\n");
 933
 934                 return false;
 935             }
 936
 937             if (nsstring_expr->getOpcode() != Instruction::GetElementPtr)
 938             {
 939                 if (log)
 940                     log->Printf("NSString initializer's str element is not a GetElementPtr expression, it's a %s", nsstring_expr->getOpcodeName());
 941
 942                 if (m_error_stream)
 943                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer is not an array\n");
 944
 945                 return false;
 946             }
 947
 948             Constant *nsstring_cstr = nsstring_expr->getOperand(0);
 949
 950             GlobalVariable *cstr_global = dyn_cast<GlobalVariable>(nsstring_cstr);
 951
 952             if (!cstr_global)
 953             {
 954                 if (log)
 955                     log->PutCString("NSString initializer's str element is not a GlobalVariable");
 956
 957                 if (m_error_stream)
 958                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to a global\n");
 959
 960                 return false;
 961             }
 962
 963             if (!cstr_global->hasInitializer())
 964             {
 965                 if (log)
 966                     log->PutCString("NSString initializer's str element does not have an initializer");
 967
 968                 if (m_error_stream)
 969                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to initialized data\n");
 970
 971                 return false;
 972             }
 973
 974             /*
 975             if (!cstr_array)
 976             {
 977                 if (log)
 978                     log->PutCString("NSString initializer's str element is not a ConstantArray");
 979
 980                 if (m_error_stream)
 981                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to an array\n");
 982
 983                 return false;
 984             }
 985
 986             if (!cstr_array->isCString())
 987             {
 988                 if (log)
 989                     log->PutCString("NSString initializer's str element is not a C string array");
 990
 991                 if (m_error_stream)
 992                     m_error_stream->Printf("Internal error [IRForTarget]: An Objective-C constant string's string initializer doesn't point to a C string\n");
 993
 994                 return false;
 995             }
 996             */
 997
 998             ConstantDataArray *cstr_array = dyn_cast<ConstantDataArray>(cstr_global->getInitializer());
 999
1000             if (log)
1001             {
1002                 if (cstr_array)
1003                     log->Printf("Found NSString constant %s, which contains \"%s\"", value_name_cstr, cstr_array->getAsString().str().c_str());
1004                 else
1005                     log->Printf("Found NSString constant %s, which contains \"\"", value_name_cstr);
1006             }
1007
1008             if (!cstr_array)
1009                 cstr_global = NULL;
1010
1011             if (!RewriteObjCConstString(nsstring_global, cstr_global))
1012             {
1013                 if (log)
1014                     log->PutCString("Error rewriting the constant string");
1015
1016                 // We don't print an error message here because RewriteObjCConstString has done so for us.
1017
1018                 return false;
1019             }
1020         }
1021     }
1022
1023     for (ValueSymbolTable::iterator vi = value_symbol_table.begin(), ve = value_symbol_table.end();
1024          vi != ve;
1025          ++vi)
1026     {
1027         std::string value_name = vi->first().str();
1028         const char *value_name_cstr = value_name.c_str();
1029
1030         if (!strcmp(value_name_cstr, "__CFConstantStringClassReference"))
1031         {
1032             GlobalVariable *gv = dyn_cast<GlobalVariable>(vi->second);
1033
1034             if (!gv)
1035             {
1036                 if (log)
1037                     log->PutCString("__CFConstantStringClassReference is not a global variable");
1038
1039                 if (m_error_stream)
1040                     m_error_stream->Printf("Internal error [IRForTarget]: Found a CFConstantStringClassReference, but it is not a global object\n");
1041
1042                 return false;
1043             }
1044
1045             gv->eraseFromParent();
1046
1047             break;
1048         }
1049     }
1050
1051     return true;
1052 }
1053
1054 static bool IsObjCSelectorRef (Value *value)
1055 {
1056     GlobalVariable *global_variable = dyn_cast<GlobalVariable>(value);
1057
1058     if (!global_variable || !global_variable->hasName() || !global_variable->getName().startswith("\01L_OBJC_SELECTOR_REFERENCES_"))
1059         return false;
1060
1061     return true;
1062 }
1063
1064 // This function does not report errors; its callers are responsible.
1065 bool
1066 IRForTarget::RewriteObjCSelector (Instruction* selector_load)
1067 {
1068     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1069
1070     LoadInst *load = dyn_cast<LoadInst>(selector_load);
1071
1072     if (!load)
1073         return false;
1074
1075     // Unpack the message name from the selector.  In LLVM IR, an objc_msgSend gets represented as
1076     //
1077     // %tmp     = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_" ; <i8*>
1078     // %call    = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %obj, i8* %tmp, ...) ; <i8*>
1079     //
1080     // where %obj is the object pointer and %tmp is the selector.
1081     //
1082     // @"\01L_OBJC_SELECTOR_REFERENCES_" is a pointer to a character array called @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_".
1083     // @"\01L_OBJC_llvm_moduleETH_VAR_NAllvm_moduleE_" contains the string.
1084
1085     // Find the pointer's initializer (a ConstantExpr with opcode GetElementPtr) and get the string from its target
1086
1087     GlobalVariable *_objc_selector_references_ = dyn_cast<GlobalVariable>(load->getPointerOperand());
1088
1089     if (!_objc_selector_references_ || !_objc_selector_references_->hasInitializer())
1090         return false;
1091
1092     Constant *osr_initializer = _objc_selector_references_->getInitializer();
1093
1094     ConstantExpr *osr_initializer_expr = dyn_cast<ConstantExpr>(osr_initializer);
1095
1096     if (!osr_initializer_expr || osr_initializer_expr->getOpcode() != Instruction::GetElementPtr)
1097         return false;
1098
1099     Value *osr_initializer_base = osr_initializer_expr->getOperand(0);
1100
1101     if (!osr_initializer_base)
1102         return false;
1103
1104     // Find the string's initializer (a ConstantArray) and get the string from it
1105
1106     GlobalVariable *_objc_meth_var_name_ = dyn_cast<GlobalVariable>(osr_initializer_base);
1107
1108     if (!_objc_meth_var_name_ || !_objc_meth_var_name_->hasInitializer())
1109         return false;
1110
1111     Constant *omvn_initializer = _objc_meth_var_name_->getInitializer();
1112
1113     ConstantDataArray *omvn_initializer_array = dyn_cast<ConstantDataArray>(omvn_initializer);
1114
1115     if (!omvn_initializer_array->isString())
1116         return false;
1117
1118     std::string omvn_initializer_string = omvn_initializer_array->getAsString();
1119
1120     if (log)
1121         log->Printf("Found Objective-C selector reference \"%s\"", omvn_initializer_string.c_str());
1122
1123     // Construct a call to sel_registerName
1124
1125     if (!m_sel_registerName)
1126     {
1127         lldb::addr_t sel_registerName_addr;
1128
1129         static lldb_private::ConstString g_sel_registerName_str ("sel_registerName");
1130         if (!m_decl_map->GetFunctionAddress (g_sel_registerName_str, sel_registerName_addr))
1131             return false;
1132
1133         if (log)
1134             log->Printf("Found sel_registerName at 0x%" PRIx64, sel_registerName_addr);
1135
1136         // Build the function type: struct objc_selector *sel_registerName(uint8_t*)
1137
1138         // The below code would be "more correct," but in actuality what's required is uint8_t*
1139         //Type *sel_type = StructType::get(m_module->getContext());
1140         //Type *sel_ptr_type = PointerType::getUnqual(sel_type);
1141         Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
1142
1143         Type *type_array[1];
1144
1145         type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
1146
1147         ArrayRef<Type *> srN_arg_types(type_array, 1);
1148
1149         llvm::Type *srN_type = FunctionType::get(sel_ptr_type, srN_arg_types, false);
1150
1151         // Build the constant containing the pointer to the function
1152         IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
1153                                                  (m_module->getPointerSize() == Module::Pointer64) ? 64 : 32);
1154         PointerType *srN_ptr_ty = PointerType::getUnqual(srN_type);
1155         Constant *srN_addr_int = ConstantInt::get(intptr_ty, sel_registerName_addr, false);
1156         m_sel_registerName = ConstantExpr::getIntToPtr(srN_addr_int, srN_ptr_ty);
1157     }
1158
1159     Value *argument_array[1];
1160
1161     Constant *omvn_pointer = ConstantExpr::getBitCast(_objc_meth_var_name_, Type::getInt8PtrTy(m_module->getContext()));
1162
1163     argument_array[0] = omvn_pointer;
1164
1165     ArrayRef<Value *> srN_arguments(argument_array, 1);
1166
1167     CallInst *srN_call = CallInst::Create(m_sel_registerName,
1168                                           srN_arguments,
1169                                           "sel_registerName",
1170                                           selector_load);
1171
1172     // Replace the load with the call in all users
1173
1174     selector_load->replaceAllUsesWith(srN_call);
1175
1176     selector_load->eraseFromParent();
1177
1178     return true;
1179 }
1180
1181 bool
1182 IRForTarget::RewriteObjCSelectors (BasicBlock &basic_block)
1183 {
1184     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1185
1186     BasicBlock::iterator ii;
1187
1188     typedef SmallVector <Instruction*, 2> InstrList;
1189     typedef InstrList::iterator InstrIterator;
1190
1191     InstrList selector_loads;
1192
1193     for (ii = basic_block.begin();
1194          ii != basic_block.end();
1195          ++ii)
1196     {
1197         Instruction &inst = *ii;
1198
1199         if (LoadInst *load = dyn_cast<LoadInst>(&inst))
1200             if (IsObjCSelectorRef(load->getPointerOperand()))
1201                 selector_loads.push_back(&inst);
1202     }
1203
1204     InstrIterator iter;
1205
1206     for (iter = selector_loads.begin();
1207          iter != selector_loads.end();
1208          ++iter)
1209     {
1210         if (!RewriteObjCSelector(*iter))
1211         {
1212             if (m_error_stream)
1213                 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't change a static reference to an Objective-C selector to a dynamic reference\n");
1214
1215             if (log)
1216                 log->PutCString("Couldn't rewrite a reference to an Objective-C selector");
1217
1218             return false;
1219         }
1220     }
1221
1222     return true;
1223 }
1224
1225 // This function does not report errors; its callers are responsible.
1226 bool
1227 IRForTarget::RewritePersistentAlloc (llvm::Instruction *persistent_alloc)
1228 {
1229     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1230
1231     AllocaInst *alloc = dyn_cast<AllocaInst>(persistent_alloc);
1232
1233     MDNode *alloc_md = alloc->getMetadata("clang.decl.ptr");
1234
1235     if (!alloc_md || !alloc_md->getNumOperands())
1236         return false;
1237
1238     ConstantInt *constant_int = dyn_cast<ConstantInt>(alloc_md->getOperand(0));
1239
1240     if (!constant_int)
1241         return false;
1242
1243     // We attempt to register this as a new persistent variable with the DeclMap.
1244
1245     uintptr_t ptr = constant_int->getZExtValue();
1246
1247     clang::VarDecl *decl = reinterpret_cast<clang::VarDecl *>(ptr);
1248
1249     lldb_private::TypeFromParser result_decl_type (decl->getType().getAsOpaquePtr(),
1250                                                    &decl->getASTContext());
1251
1252     StringRef decl_name (decl->getName());
1253     lldb_private::ConstString persistent_variable_name (decl_name.data(), decl_name.size());
1254     if (!m_decl_map->AddPersistentVariable(decl, persistent_variable_name, result_decl_type, false, false))
1255         return false;
1256
1257     GlobalVariable *persistent_global = new GlobalVariable((*m_module),
1258                                                            alloc->getType(),
1259                                                            false, /* not constant */
1260                                                            GlobalValue::ExternalLinkage,
1261                                                            NULL, /* no initializer */
1262                                                            alloc->getName().str().c_str());
1263
1264     // What we're going to do here is make believe this was a regular old external
1265     // variable.  That means we need to make the metadata valid.
1266
1267     NamedMDNode *named_metadata = m_module->getOrInsertNamedMetadata("clang.global.decl.ptrs");
1268
1269     llvm::Value* values[2];
1270     values[0] = persistent_global;
1271     values[1] = constant_int;
1272
1273     ArrayRef<llvm::Value*> value_ref(values, 2);
1274
1275     MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
1276     named_metadata->addOperand(persistent_global_md);
1277
1278     // Now, since the variable is a pointer variable, we will drop in a load of that
1279     // pointer variable.
1280
1281     LoadInst *persistent_load = new LoadInst (persistent_global, "", alloc);
1282
1283     if (log)
1284         log->Printf("Replacing \"%s\" with \"%s\"",
1285                     PrintValue(alloc).c_str(),
1286                     PrintValue(persistent_load).c_str());
1287
1288     alloc->replaceAllUsesWith(persistent_load);
1289     alloc->eraseFromParent();
1290
1291     return true;
1292 }
1293
1294 bool
1295 IRForTarget::RewritePersistentAllocs(llvm::BasicBlock &basic_block)
1296 {
1297     if (!m_resolve_vars)
1298         return true;
1299
1300     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1301
1302     BasicBlock::iterator ii;
1303
1304     typedef SmallVector <Instruction*, 2> InstrList;
1305     typedef InstrList::iterator InstrIterator;
1306
1307     InstrList pvar_allocs;
1308
1309     for (ii = basic_block.begin();
1310          ii != basic_block.end();
1311          ++ii)
1312     {
1313         Instruction &inst = *ii;
1314
1315         if (AllocaInst *alloc = dyn_cast<AllocaInst>(&inst))
1316         {
1317             llvm::StringRef alloc_name = alloc->getName();
1318
1319             if (alloc_name.startswith("$") &&
1320                 !alloc_name.startswith("$__lldb"))
1321             {
1322                 if (alloc_name.find_first_of("0123456789") == 1)
1323                 {
1324                     if (log)
1325                         log->Printf("Rejecting a numeric persistent variable.");
1326
1327                     if (m_error_stream)
1328                         m_error_stream->Printf("Error [IRForTarget]: Names starting with $0, $1, ... are reserved for use as result names\n");
1329
1330                     return false;
1331                 }
1332
1333                 pvar_allocs.push_back(alloc);
1334             }
1335         }
1336     }
1337
1338     InstrIterator iter;
1339
1340     for (iter = pvar_allocs.begin();
1341          iter != pvar_allocs.end();
1342          ++iter)
1343     {
1344         if (!RewritePersistentAlloc(*iter))
1345         {
1346             if (m_error_stream)
1347                 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite the creation of a persistent variable\n");
1348
1349             if (log)
1350                 log->PutCString("Couldn't rewrite the creation of a persistent variable");
1351
1352             return false;
1353         }
1354     }
1355
1356     return true;
1357 }
1358
1359 bool
1360 IRForTarget::MaterializeInitializer (uint8_t *data, Constant *initializer)
1361 {
1362     if (!initializer)
1363         return true;
1364
1365     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1366
1367     if (log && log->GetVerbose())
1368         log->Printf("  MaterializeInitializer(%p, %s)", data, PrintValue(initializer).c_str());
1369
1370     Type *initializer_type = initializer->getType();
1371
1372     if (ConstantInt *int_initializer = dyn_cast<ConstantInt>(initializer))
1373     {
1374         memcpy (data, int_initializer->getValue().getRawData(), m_target_data->getTypeStoreSize(initializer_type));
1375         return true;
1376     }
1377     else if (ConstantDataArray *array_initializer = dyn_cast<ConstantDataArray>(initializer))
1378     {
1379         if (array_initializer->isString())
1380         {
1381             std::string array_initializer_string = array_initializer->getAsString();
1382             memcpy (data, array_initializer_string.c_str(), m_target_data->getTypeStoreSize(initializer_type));
1383         }
1384         else
1385         {
1386             ArrayType *array_initializer_type = array_initializer->getType();
1387             Type *array_element_type = array_initializer_type->getElementType();
1388
1389             size_t element_size = m_target_data->getTypeAllocSize(array_element_type);
1390
1391             for (unsigned i = 0; i < array_initializer->getNumOperands(); ++i)
1392             {
1393                 Value *operand_value = array_initializer->getOperand(i);
1394                 Constant *operand_constant = dyn_cast<Constant>(operand_value);
1395
1396                 if (!operand_constant)
1397                     return false;
1398
1399                 if (!MaterializeInitializer(data + (i * element_size), operand_constant))
1400                     return false;
1401             }
1402         }
1403         return true;
1404     }
1405     else if (ConstantStruct *struct_initializer = dyn_cast<ConstantStruct>(initializer))
1406     {
1407         StructType *struct_initializer_type = struct_initializer->getType();
1408         const StructLayout *struct_layout = m_target_data->getStructLayout(struct_initializer_type);
1409
1410         for (unsigned i = 0;
1411              i < struct_initializer->getNumOperands();
1412              ++i)
1413         {
1414             if (!MaterializeInitializer(data + struct_layout->getElementOffset(i), struct_initializer->getOperand(i)))
1415                 return false;
1416         }
1417         return true;
1418     }
1419     else if (isa<ConstantAggregateZero>(initializer))
1420     {
1421         memset(data, 0, m_target_data->getTypeStoreSize(initializer_type));
1422         return true;
1423     }
1424     return false;
1425 }
1426
1427 bool
1428 IRForTarget::MaterializeInternalVariable (GlobalVariable *global_variable)
1429 {
1430     if (GlobalVariable::isExternalLinkage(global_variable->getLinkage()))
1431         return false;
1432
1433     if (global_variable == m_reloc_placeholder)
1434         return true;
1435
1436     uint64_t offset = m_data_allocator.GetStream().GetSize();
1437
1438     llvm::Type *variable_type = global_variable->getType();
1439
1440     Constant *initializer = global_variable->getInitializer();
1441
1442     llvm::Type *initializer_type = initializer->getType();
1443
1444     size_t size = m_target_data->getTypeAllocSize(initializer_type);
1445     size_t align = m_target_data->getPrefTypeAlignment(initializer_type);
1446
1447     const size_t mask = (align - 1);
1448     uint64_t aligned_offset = (offset + mask) & ~mask;
1449     m_data_allocator.GetStream().PutNHex8(aligned_offset - offset, 0);
1450     offset = aligned_offset;
1451
1452     lldb_private::DataBufferHeap data(size, '\0');
1453
1454     if (initializer)
1455         if (!MaterializeInitializer(data.GetBytes(), initializer))
1456             return false;
1457
1458     m_data_allocator.GetStream().Write(data.GetBytes(), data.GetByteSize());
1459
1460     Constant *new_pointer = BuildRelocation(variable_type, offset);
1461
1462     global_variable->replaceAllUsesWith(new_pointer);
1463
1464     global_variable->eraseFromParent();
1465
1466     return true;
1467 }
1468
1469 // This function does not report errors; its callers are responsible.
1470 bool
1471 IRForTarget::MaybeHandleVariable (Value *llvm_value_ptr)
1472 {
1473     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1474
1475     if (log)
1476         log->Printf("MaybeHandleVariable (%s)", PrintValue(llvm_value_ptr).c_str());
1477
1478     if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(llvm_value_ptr))
1479     {
1480         switch (constant_expr->getOpcode())
1481         {
1482         default:
1483             break;
1484         case Instruction::GetElementPtr:
1485         case Instruction::BitCast:
1486             Value *s = constant_expr->getOperand(0);
1487             if (!MaybeHandleVariable(s))
1488                 return false;
1489         }
1490     }
1491     else if (GlobalVariable *global_variable = dyn_cast<GlobalVariable>(llvm_value_ptr))
1492     {
1493         if (!GlobalValue::isExternalLinkage(global_variable->getLinkage()))
1494             return MaterializeInternalVariable(global_variable);
1495
1496         clang::NamedDecl *named_decl = DeclForGlobal(global_variable);
1497
1498         if (!named_decl)
1499         {
1500             if (IsObjCSelectorRef(llvm_value_ptr))
1501                 return true;
1502
1503             if (!global_variable->hasExternalLinkage())
1504                 return true;
1505
1506             if (log)
1507                 log->Printf("Found global variable \"%s\" without metadata", global_variable->getName().str().c_str());
1508
1509             return false;
1510         }
1511
1512         std::string name (named_decl->getName().str());
1513
1514         clang::ValueDecl *value_decl = dyn_cast<clang::ValueDecl>(named_decl);
1515         if (value_decl == NULL)
1516             return false;
1517
1518         lldb_private::ClangASTType clang_type(&value_decl->getASTContext(), value_decl->getType());
1519
1520         const Type *value_type = NULL;
1521
1522         if (name[0] == '$')
1523         {
1524             // The $__lldb_expr_result name indicates the the return value has allocated as
1525             // a static variable.  Per the comment at ASTResultSynthesizer::SynthesizeBodyResult,
1526             // accesses to this static variable need to be redirected to the result of dereferencing
1527             // a pointer that is passed in as one of the arguments.
1528             //
1529             // Consequently, when reporting the size of the type, we report a pointer type pointing
1530             // to the type of $__lldb_expr_result, not the type itself.
1531             //
1532             // We also do this for any user-declared persistent variables.
1533             clang_type = clang_type.GetPointerType();
1534             value_type = PointerType::get(global_variable->getType(), 0);
1535         }
1536         else
1537         {
1538             value_type = global_variable->getType();
1539         }
1540
1541         const uint64_t value_size = clang_type.GetByteSize();
1542         off_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull;
1543
1544         if (log)
1545         {
1546             log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRId64 "]",
1547                         name.c_str(),
1548                         clang_type.GetQualType().getAsString().c_str(),
1549                         PrintType(value_type).c_str(),
1550                         value_size,
1551                         value_alignment);
1552         }
1553
1554
1555         if (named_decl && !m_decl_map->AddValueToStruct(named_decl,
1556                                                         lldb_private::ConstString (name.c_str()),
1557                                                         llvm_value_ptr,
1558                                                         value_size,
1559                                                         value_alignment))
1560         {
1561             if (!global_variable->hasExternalLinkage())
1562                 return true;
1563             else if (HandleSymbol (global_variable))
1564                 return true;
1565             else
1566                 return false;
1567         }
1568     }
1569     else if (dyn_cast<llvm::Function>(llvm_value_ptr))
1570     {
1571         if (log)
1572             log->Printf("Function pointers aren't handled right now");
1573
1574         return false;
1575     }
1576
1577     return true;
1578 }
1579
1580 // This function does not report errors; its callers are responsible.
1581 bool
1582 IRForTarget::HandleSymbol (Value *symbol)
1583 {
1584     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1585
1586     lldb_private::ConstString name(symbol->getName().str().c_str());
1587
1588     lldb::addr_t symbol_addr = m_decl_map->GetSymbolAddress (name, lldb::eSymbolTypeAny);
1589
1590     if (symbol_addr == LLDB_INVALID_ADDRESS)
1591     {
1592         if (log)
1593             log->Printf ("Symbol \"%s\" had no address", name.GetCString());
1594
1595         return false;
1596     }
1597
1598     if (log)
1599         log->Printf("Found \"%s\" at 0x%" PRIx64, name.GetCString(), symbol_addr);
1600
1601     Type *symbol_type = symbol->getType();
1602     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
1603                                              (m_module->getPointerSize() == Module::Pointer64) ? 64 : 32);
1604
1605     Constant *symbol_addr_int = ConstantInt::get(intptr_ty, symbol_addr, false);
1606
1607     Value *symbol_addr_ptr = ConstantExpr::getIntToPtr(symbol_addr_int, symbol_type);
1608
1609     if (log)
1610         log->Printf("Replacing %s with %s", PrintValue(symbol).c_str(), PrintValue(symbol_addr_ptr).c_str());
1611
1612     symbol->replaceAllUsesWith(symbol_addr_ptr);
1613
1614     return true;
1615 }
1616
1617 bool
1618 IRForTarget::MaybeHandleCallArguments (CallInst *Old)
1619 {
1620     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1621
1622     if (log)
1623         log->Printf("MaybeHandleCallArguments(%s)", PrintValue(Old).c_str());
1624
1625     for (unsigned op_index = 0, num_ops = Old->getNumArgOperands();
1626          op_index < num_ops;
1627          ++op_index)
1628         if (!MaybeHandleVariable(Old->getArgOperand(op_index))) // conservatively believe that this is a store
1629         {
1630             if (m_error_stream)
1631                 m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite one of the arguments of a function call.\n");
1632
1633             return false;
1634         }
1635
1636     return true;
1637 }
1638
1639 bool
1640 IRForTarget::HandleObjCClass(Value *classlist_reference)
1641 {
1642     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1643
1644     GlobalVariable *global_variable = dyn_cast<GlobalVariable>(classlist_reference);
1645
1646     if (!global_variable)
1647         return false;
1648
1649     Constant *initializer = global_variable->getInitializer();
1650
1651     if (!initializer)
1652         return false;
1653
1654     if (!initializer->hasName())
1655         return false;
1656
1657     StringRef name(initializer->getName());
1658     lldb_private::ConstString name_cstr(name.str().c_str());
1659     lldb::addr_t class_ptr = m_decl_map->GetSymbolAddress(name_cstr, lldb::eSymbolTypeObjCClass);
1660
1661     if (log)
1662         log->Printf("Found reference to Objective-C class %s (0x%llx)", name_cstr.AsCString(), (unsigned long long)class_ptr);
1663
1664     if (class_ptr == LLDB_INVALID_ADDRESS)
1665         return false;
1666
1667     if (global_variable->use_begin() == global_variable->use_end())
1668         return false;
1669
1670     SmallVector<LoadInst *, 2> load_instructions;
1671
1672     for (Value::use_iterator i = global_variable->use_begin(), e = global_variable->use_end();
1673          i != e;
1674          ++i)
1675     {
1676         if (LoadInst *load_instruction = dyn_cast<LoadInst>(*i))
1677             load_instructions.push_back(load_instruction);
1678     }
1679
1680     if (load_instructions.empty())
1681         return false;
1682
1683     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
1684                                              (m_module->getPointerSize()
1685                                               == Module::Pointer64) ? 64 : 32);
1686
1687     Constant *class_addr = ConstantInt::get(intptr_ty, (uint64_t)class_ptr);
1688
1689     for (LoadInst *load_instruction : load_instructions)
1690     {
1691         Constant *class_bitcast = ConstantExpr::getIntToPtr(class_addr, load_instruction->getType());
1692
1693         load_instruction->replaceAllUsesWith(class_bitcast);
1694
1695         load_instruction->eraseFromParent();
1696     }
1697
1698     return true;
1699 }
1700
1701 bool
1702 IRForTarget::RemoveCXAAtExit (BasicBlock &basic_block)
1703 {
1704     BasicBlock::iterator ii;
1705
1706     std::vector<CallInst *> calls_to_remove;
1707
1708     for (ii = basic_block.begin();
1709          ii != basic_block.end();
1710          ++ii)
1711     {
1712         Instruction &inst = *ii;
1713
1714         CallInst *call = dyn_cast<CallInst>(&inst);
1715
1716         // MaybeHandleCallArguments handles error reporting; we are silent here
1717         if (!call)
1718             continue;
1719
1720         bool remove = false;
1721
1722         llvm::Function *func = call->getCalledFunction();
1723
1724         if (func && func->getName() == "__cxa_atexit")
1725             remove = true;
1726
1727         llvm::Value *val = call->getCalledValue();
1728
1729         if (val && val->getName() == "__cxa_atexit")
1730             remove = true;
1731
1732         if (remove)
1733             calls_to_remove.push_back(call);
1734     }
1735
1736     for (std::vector<CallInst *>::iterator ci = calls_to_remove.begin(), ce = calls_to_remove.end();
1737          ci != ce;
1738          ++ci)
1739     {
1740         (*ci)->eraseFromParent();
1741     }
1742
1743     return true;
1744 }
1745
1746 bool
1747 IRForTarget::ResolveCalls(BasicBlock &basic_block)
1748 {
1749     /////////////////////////////////////////////////////////////////////////
1750     // Prepare the current basic block for execution in the remote process
1751     //
1752
1753     BasicBlock::iterator ii;
1754
1755     for (ii = basic_block.begin();
1756          ii != basic_block.end();
1757          ++ii)
1758     {
1759         Instruction &inst = *ii;
1760
1761         CallInst *call = dyn_cast<CallInst>(&inst);
1762
1763         // MaybeHandleCallArguments handles error reporting; we are silent here
1764         if (call && !MaybeHandleCallArguments(call))
1765             return false;
1766     }
1767
1768     return true;
1769 }
1770
1771 bool
1772 IRForTarget::ResolveExternals (Function &llvm_function)
1773 {
1774     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1775
1776     for (Module::global_iterator global = m_module->global_begin(), end = m_module->global_end();
1777          global != end;
1778          ++global)
1779     {
1780         if (!global)
1781         {
1782             if (m_error_stream)
1783                 m_error_stream->Printf("Internal error [IRForTarget]: global variable is NULL");
1784
1785             return false;
1786         }
1787
1788         std::string global_name = (*global).getName().str();
1789
1790         if (log)
1791             log->Printf("Examining %s, DeclForGlobalValue returns %p",
1792                         global_name.c_str(),
1793                         DeclForGlobal(global));
1794
1795         if (global_name.find("OBJC_IVAR") == 0)
1796         {
1797             if (!HandleSymbol(global))
1798             {
1799                 if (m_error_stream)
1800                     m_error_stream->Printf("Error [IRForTarget]: Couldn't find Objective-C indirect ivar symbol %s\n", global_name.c_str());
1801
1802                 return false;
1803             }
1804         }
1805         else if (global_name.find("OBJC_CLASSLIST_REFERENCES_$") != global_name.npos)
1806         {
1807             if (!HandleObjCClass(global))
1808             {
1809                 if (m_error_stream)
1810                     m_error_stream->Printf("Error [IRForTarget]: Couldn't resolve the class for an Objective-C static method call\n");
1811
1812                 return false;
1813             }
1814         }
1815         else if (global_name.find("OBJC_CLASSLIST_SUP_REFS_$") != global_name.npos)
1816         {
1817             if (!HandleObjCClass(global))
1818             {
1819                 if (m_error_stream)
1820                     m_error_stream->Printf("Error [IRForTarget]: Couldn't resolve the class for an Objective-C static method call\n");
1821
1822                 return false;
1823             }
1824         }
1825         else if (DeclForGlobal(global))
1826         {
1827             if (!MaybeHandleVariable (global))
1828             {
1829                 if (m_error_stream)
1830                     m_error_stream->Printf("Internal error [IRForTarget]: Couldn't rewrite external variable %s\n", global_name.c_str());
1831
1832                 return false;
1833             }
1834         }
1835     }
1836
1837     return true;
1838 }
1839
1840 bool
1841 IRForTarget::ReplaceStrings ()
1842 {
1843     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1844
1845     typedef std::map <GlobalVariable *, size_t> OffsetsTy;
1846
1847     OffsetsTy offsets;
1848
1849     for (Module::global_iterator gi = m_module->global_begin(), ge = m_module->global_end();
1850          gi != ge;
1851          ++gi)
1852     {
1853         GlobalVariable *gv = gi;
1854
1855         if (!gv->hasInitializer())
1856             continue;
1857
1858         Constant *gc = gv->getInitializer();
1859
1860         std::string str;
1861
1862         if (gc->isNullValue())
1863         {
1864             Type *gc_type = gc->getType();
1865
1866             ArrayType *gc_array_type = dyn_cast<ArrayType>(gc_type);
1867
1868             if (!gc_array_type)
1869                 continue;
1870
1871             Type *gc_element_type = gc_array_type->getElementType();
1872
1873             IntegerType *gc_integer_type = dyn_cast<IntegerType>(gc_element_type);
1874
1875             if (gc_integer_type->getBitWidth() != 8)
1876                 continue;
1877
1878             str = "";
1879         }
1880         else
1881         {
1882             ConstantDataArray *gc_array = dyn_cast<ConstantDataArray>(gc);
1883
1884             if (!gc_array)
1885                 continue;
1886
1887             if (!gc_array->isCString())
1888                 continue;
1889
1890             if (log)
1891                 log->Printf("Found a GlobalVariable with string initializer %s", PrintValue(gc).c_str());
1892
1893             str = gc_array->getAsString();
1894         }
1895
1896         offsets[gv] = m_data_allocator.GetStream().GetSize();
1897
1898         m_data_allocator.GetStream().Write(str.c_str(), str.length() + 1);
1899     }
1900
1901     Type *char_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
1902
1903     for (OffsetsTy::iterator oi = offsets.begin(), oe = offsets.end();
1904          oi != oe;
1905          ++oi)
1906     {
1907         GlobalVariable *gv = oi->first;
1908         size_t offset = oi->second;
1909
1910         Constant *new_initializer = BuildRelocation(char_ptr_ty, offset);
1911
1912         if (log)
1913             log->Printf("Replacing GV %s with %s", PrintValue(gv).c_str(), PrintValue(new_initializer).c_str());
1914
1915         for (GlobalVariable::use_iterator ui = gv->use_begin(), ue = gv->use_end();
1916              ui != ue;
1917              ++ui)
1918         {
1919             if (log)
1920                 log->Printf("Found use %s", PrintValue(*ui).c_str());
1921
1922             ConstantExpr *const_expr = dyn_cast<ConstantExpr>(*ui);
1923             StoreInst *store_inst = dyn_cast<StoreInst>(*ui);
1924
1925             if (const_expr)
1926             {
1927                 if (const_expr->getOpcode() != Instruction::GetElementPtr)
1928                 {
1929                     if (log)
1930                         log->Printf("Use (%s) of string variable is not a GetElementPtr constant", PrintValue(const_expr).c_str());
1931
1932                     return false;
1933                 }
1934
1935                 Constant *bit_cast = ConstantExpr::getBitCast(new_initializer, const_expr->getOperand(0)->getType());
1936                 Constant *new_gep = const_expr->getWithOperandReplaced(0, bit_cast);
1937
1938                 const_expr->replaceAllUsesWith(new_gep);
1939             }
1940             else if (store_inst)
1941             {
1942                 Constant *bit_cast = ConstantExpr::getBitCast(new_initializer, store_inst->getValueOperand()->getType());
1943
1944                 store_inst->setOperand(0, bit_cast);
1945             }
1946             else
1947             {
1948                 if (log)
1949                     log->Printf("Use (%s) of string variable is neither a constant nor a store", PrintValue(const_expr).c_str());
1950
1951                 return false;
1952             }
1953         }
1954
1955         gv->eraseFromParent();
1956     }
1957
1958     return true;
1959 }
1960
1961 bool
1962 IRForTarget::ReplaceStaticLiterals (llvm::BasicBlock &basic_block)
1963 {
1964     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
1965
1966     typedef SmallVector <Value*, 2> ConstantList;
1967     typedef SmallVector <llvm::Instruction*, 2> UserList;
1968     typedef ConstantList::iterator ConstantIterator;
1969     typedef UserList::iterator UserIterator;
1970
1971     ConstantList static_constants;
1972     UserList static_users;
1973
1974     for (BasicBlock::iterator ii = basic_block.begin(), ie = basic_block.end();
1975          ii != ie;
1976          ++ii)
1977     {
1978         llvm::Instruction &inst = *ii;
1979
1980         for (Instruction::op_iterator oi = inst.op_begin(), oe = inst.op_end();
1981              oi != oe;
1982              ++oi)
1983         {
1984             Value *operand_val = oi->get();
1985
1986             ConstantFP *operand_constant_fp = dyn_cast<ConstantFP>(operand_val);
1987
1988             if (operand_constant_fp/* && operand_constant_fp->getType()->isX86_FP80Ty()*/)
1989             {
1990                 static_constants.push_back(operand_val);
1991                 static_users.push_back(ii);
1992             }
1993         }
1994     }
1995
1996     ConstantIterator constant_iter;
1997     UserIterator user_iter;
1998
1999     for (constant_iter = static_constants.begin(), user_iter = static_users.begin();
2000          constant_iter != static_constants.end();
2001          ++constant_iter, ++user_iter)
2002     {
2003         Value *operand_val = *constant_iter;
2004         llvm::Instruction *inst = *user_iter;
2005
2006         ConstantFP *operand_constant_fp = dyn_cast<ConstantFP>(operand_val);
2007
2008         if (operand_constant_fp)
2009         {
2010             Type *operand_type = operand_constant_fp->getType();
2011
2012             APFloat operand_apfloat = operand_constant_fp->getValueAPF();
2013             APInt operand_apint = operand_apfloat.bitcastToAPInt();
2014
2015             const uint8_t* operand_raw_data = (const uint8_t*)operand_apint.getRawData();
2016             size_t operand_data_size = operand_apint.getBitWidth() / 8;
2017
2018             if (log)
2019             {
2020                 std::string s;
2021                 raw_string_ostream ss(s);
2022                 for (size_t index = 0;
2023                      index < operand_data_size;
2024                      ++index)
2025                 {
2026                     ss << (uint32_t)operand_raw_data[index];
2027                     ss << " ";
2028                 }
2029                 ss.flush();
2030
2031                 log->Printf("Found ConstantFP with size %zu and raw data %s", operand_data_size, s.c_str());
2032             }
2033
2034             lldb_private::DataBufferHeap data(operand_data_size, 0);
2035
2036             if (lldb::endian::InlHostByteOrder() != m_data_allocator.GetStream().GetByteOrder())
2037             {
2038                 uint8_t *data_bytes = data.GetBytes();
2039
2040                 for (size_t index = 0;
2041                      index < operand_data_size;
2042                      ++index)
2043                 {
2044                     data_bytes[index] = operand_raw_data[operand_data_size - (1 + index)];
2045                 }
2046             }
2047             else
2048             {
2049                 memcpy(data.GetBytes(), operand_raw_data, operand_data_size);
2050             }
2051
2052             uint64_t offset = m_data_allocator.GetStream().GetSize();
2053
2054             size_t align = m_target_data->getPrefTypeAlignment(operand_type);
2055
2056             const size_t mask = (align - 1);
2057             uint64_t aligned_offset = (offset + mask) & ~mask;
2058             m_data_allocator.GetStream().PutNHex8(aligned_offset - offset, 0);
2059             offset = aligned_offset;
2060
2061             m_data_allocator.GetStream().Write(data.GetBytes(), operand_data_size);
2062
2063             llvm::Type *fp_ptr_ty = operand_constant_fp->getType()->getPointerTo();
2064
2065             Constant *new_pointer = BuildRelocation(fp_ptr_ty, aligned_offset);
2066
2067             llvm::LoadInst *fp_load = new llvm::LoadInst(new_pointer, "fp_load", inst);
2068
2069             operand_constant_fp->replaceAllUsesWith(fp_load);
2070         }
2071     }
2072
2073     return true;
2074 }
2075
2076 static bool isGuardVariableRef(Value *V)
2077 {
2078     Constant *Old = NULL;
2079
2080     if (!(Old = dyn_cast<Constant>(V)))
2081         return false;
2082
2083     ConstantExpr *CE = NULL;
2084
2085     if ((CE = dyn_cast<ConstantExpr>(V)))
2086     {
2087         if (CE->getOpcode() != Instruction::BitCast)
2088             return false;
2089
2090         Old = CE->getOperand(0);
2091     }
2092
2093     GlobalVariable *GV = dyn_cast<GlobalVariable>(Old);
2094
2095     if (!GV || !GV->hasName() || !GV->getName().startswith("_ZGV"))
2096         return false;
2097
2098     return true;
2099 }
2100
2101 void
2102 IRForTarget::TurnGuardLoadIntoZero(llvm::Instruction* guard_load)
2103 {
2104     Constant* zero(ConstantInt::get(Type::getInt8Ty(m_module->getContext()), 0, true));
2105
2106     Value::use_iterator ui;
2107
2108     for (ui = guard_load->use_begin();
2109          ui != guard_load->use_end();
2110          ++ui)
2111     {
2112         if (isa<Constant>(*ui))
2113         {
2114             // do nothing for the moment
2115         }
2116         else
2117         {
2118             ui->replaceUsesOfWith(guard_load, zero);
2119         }
2120     }
2121
2122     guard_load->eraseFromParent();
2123 }
2124
2125 static void ExciseGuardStore(Instruction* guard_store)
2126 {
2127     guard_store->eraseFromParent();
2128 }
2129
2130 bool
2131 IRForTarget::RemoveGuards(BasicBlock &basic_block)
2132 {
2133     ///////////////////////////////////////////////////////
2134     // Eliminate any reference to guard variables found.
2135     //
2136
2137     BasicBlock::iterator ii;
2138
2139     typedef SmallVector <Instruction*, 2> InstrList;
2140     typedef InstrList::iterator InstrIterator;
2141
2142     InstrList guard_loads;
2143     InstrList guard_stores;
2144
2145     for (ii = basic_block.begin();
2146          ii != basic_block.end();
2147          ++ii)
2148     {
2149         Instruction &inst = *ii;
2150
2151         if (LoadInst *load = dyn_cast<LoadInst>(&inst))
2152             if (isGuardVariableRef(load->getPointerOperand()))
2153                 guard_loads.push_back(&inst);
2154
2155         if (StoreInst *store = dyn_cast<StoreInst>(&inst))
2156             if (isGuardVariableRef(store->getPointerOperand()))
2157                 guard_stores.push_back(&inst);
2158     }
2159
2160     InstrIterator iter;
2161
2162     for (iter = guard_loads.begin();
2163          iter != guard_loads.end();
2164          ++iter)
2165         TurnGuardLoadIntoZero(*iter);
2166
2167     for (iter = guard_stores.begin();
2168          iter != guard_stores.end();
2169          ++iter)
2170         ExciseGuardStore(*iter);
2171
2172     return true;
2173 }
2174
2175 // This function does not report errors; its callers are responsible.
2176 bool
2177 IRForTarget::UnfoldConstant(Constant *old_constant,
2178                             FunctionValueCache &value_maker,
2179                             FunctionValueCache &entry_instruction_finder)
2180 {
2181     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2182
2183     Value::use_iterator ui;
2184
2185     SmallVector<User*, 16> users;
2186
2187     // We do this because the use list might change, invalidating our iterator.
2188     // Much better to keep a work list ourselves.
2189     for (ui = old_constant->use_begin();
2190          ui != old_constant->use_end();
2191          ++ui)
2192         users.push_back(*ui);
2193
2194     for (size_t i = 0;
2195          i < users.size();
2196          ++i)
2197     {
2198         User *user = users[i];
2199
2200         if (Constant *constant = dyn_cast<Constant>(user))
2201         {
2202             // synthesize a new non-constant equivalent of the constant
2203
2204             if (ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant))
2205             {
2206                 switch (constant_expr->getOpcode())
2207                 {
2208                 default:
2209                     if (log)
2210                         log->Printf("Unhandled constant expression type: \"%s\"", PrintValue(constant_expr).c_str());
2211                     return false;
2212                 case Instruction::BitCast:
2213                     {
2214                         FunctionValueCache bit_cast_maker ([&value_maker, &entry_instruction_finder, old_constant, constant_expr] (llvm::Function *function)->llvm::Value* {
2215                             // UnaryExpr
2216                             //   OperandList[0] is value
2217
2218                             if (constant_expr->getOperand(0) != old_constant)
2219                                 return constant_expr;
2220
2221                             return new BitCastInst(value_maker.GetValue(function),
2222                                                    constant_expr->getType(),
2223                                                    "",
2224                                                    llvm::cast<Instruction>(entry_instruction_finder.GetValue(function)));
2225                         });
2226
2227                         if (!UnfoldConstant(constant_expr, bit_cast_maker, entry_instruction_finder))
2228                             return false;
2229                     }
2230                     break;
2231                 case Instruction::GetElementPtr:
2232                     {
2233                         // GetElementPtrConstantExpr
2234                         //   OperandList[0] is base
2235                         //   OperandList[1]... are indices
2236
2237                         FunctionValueCache get_element_pointer_maker ([&value_maker, &entry_instruction_finder, old_constant, constant_expr] (llvm::Function *function)->llvm::Value* {
2238                             Value *ptr = constant_expr->getOperand(0);
2239
2240                             if (ptr == old_constant)
2241                                 ptr = value_maker.GetValue(function);
2242
2243                             std::vector<Value*> index_vector;
2244
2245                             unsigned operand_index;
2246                             unsigned num_operands = constant_expr->getNumOperands();
2247
2248                             for (operand_index = 1;
2249                                  operand_index < num_operands;
2250                                  ++operand_index)
2251                             {
2252                                 Value *operand = constant_expr->getOperand(operand_index);
2253
2254                                 if (operand == old_constant)
2255                                     operand = value_maker.GetValue(function);
2256
2257                                 index_vector.push_back(operand);
2258                             }
2259
2260                             ArrayRef <Value*> indices(index_vector);
2261
2262                             return GetElementPtrInst::Create(ptr, indices, "", llvm::cast<Instruction>(entry_instruction_finder.GetValue(function)));
2263                         });
2264
2265                         if (!UnfoldConstant(constant_expr, get_element_pointer_maker, entry_instruction_finder))
2266                             return false;
2267                     }
2268                     break;
2269                 }
2270             }
2271             else
2272             {
2273                 if (log)
2274                     log->Printf("Unhandled constant type: \"%s\"", PrintValue(constant).c_str());
2275                 return false;
2276             }
2277         }
2278         else
2279         {
2280             if (Instruction *inst = llvm::dyn_cast<Instruction>(user))
2281             {
2282                 inst->replaceUsesOfWith(old_constant, value_maker.GetValue(inst->getParent()->getParent()));
2283             }
2284             else
2285             {
2286                 if (log)
2287                     log->Printf("Unhandled non-constant type: \"%s\"", PrintValue(user).c_str());
2288                 return false;
2289             }
2290         }
2291     }
2292
2293     if (!isa<GlobalValue>(old_constant))
2294     {
2295         old_constant->destroyConstant();
2296     }
2297
2298     return true;
2299 }
2300
2301 bool
2302 IRForTarget::ReplaceVariables (Function &llvm_function)
2303 {
2304     if (!m_resolve_vars)
2305         return true;
2306
2307     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2308
2309     m_decl_map->DoStructLayout();
2310
2311     if (log)
2312         log->Printf("Element arrangement:");
2313
2314     uint32_t num_elements;
2315     uint32_t element_index;
2316
2317     size_t size;
2318     off_t alignment;
2319
2320     if (!m_decl_map->GetStructInfo (num_elements, size, alignment))
2321         return false;
2322
2323     Function::arg_iterator iter(llvm_function.getArgumentList().begin());
2324
2325     if (iter == llvm_function.getArgumentList().end())
2326     {
2327         if (m_error_stream)
2328             m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes no arguments (should take at least a struct pointer)");
2329
2330         return false;
2331     }
2332
2333     Argument *argument = iter;
2334
2335     if (argument->getName().equals("this"))
2336     {
2337         ++iter;
2338
2339         if (iter == llvm_function.getArgumentList().end())
2340         {
2341             if (m_error_stream)
2342                 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'this' argument (should take a struct pointer too)");
2343
2344             return false;
2345         }
2346
2347         argument = iter;
2348     }
2349     else if (argument->getName().equals("self"))
2350     {
2351         ++iter;
2352
2353         if (iter == llvm_function.getArgumentList().end())
2354         {
2355             if (m_error_stream)
2356                 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'self' argument (should take '_cmd' and a struct pointer too)");
2357
2358             return false;
2359         }
2360
2361         if (!iter->getName().equals("_cmd"))
2362         {
2363             if (m_error_stream)
2364                 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes '%s' after 'self' argument (should take '_cmd')", iter->getName().str().c_str());
2365
2366             return false;
2367         }
2368
2369         ++iter;
2370
2371         if (iter == llvm_function.getArgumentList().end())
2372         {
2373             if (m_error_stream)
2374                 m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes only 'self' and '_cmd' arguments (should take a struct pointer too)");
2375
2376             return false;
2377         }
2378
2379         argument = iter;
2380     }
2381
2382     if (!argument->getName().equals("$__lldb_arg"))
2383     {
2384         if (m_error_stream)
2385             m_error_stream->Printf("Internal error [IRForTarget]: Wrapper takes an argument named '%s' instead of the struct pointer", argument->getName().str().c_str());
2386
2387         return false;
2388     }
2389
2390     if (log)
2391         log->Printf("Arg: \"%s\"", PrintValue(argument).c_str());
2392
2393     BasicBlock &entry_block(llvm_function.getEntryBlock());
2394     Instruction *FirstEntryInstruction(entry_block.getFirstNonPHIOrDbg());
2395
2396     if (!FirstEntryInstruction)
2397     {
2398         if (m_error_stream)
2399             m_error_stream->Printf("Internal error [IRForTarget]: Couldn't find the first instruction in the wrapper for use in rewriting");
2400
2401         return false;
2402     }
2403
2404     LLVMContext &context(m_module->getContext());
2405     IntegerType *offset_type(Type::getInt32Ty(context));
2406
2407     if (!offset_type)
2408     {
2409         if (m_error_stream)
2410             m_error_stream->Printf("Internal error [IRForTarget]: Couldn't produce an offset type");
2411
2412         return false;
2413     }
2414
2415     for (element_index = 0; element_index < num_elements; ++element_index)
2416     {
2417         const clang::NamedDecl *decl = NULL;
2418         Value *value = NULL;
2419         off_t offset;
2420         lldb_private::ConstString name;
2421
2422         if (!m_decl_map->GetStructElement (decl, value, offset, name, element_index))
2423         {
2424             if (m_error_stream)
2425                 m_error_stream->Printf("Internal error [IRForTarget]: Structure information is incomplete");
2426
2427             return false;
2428         }
2429
2430         if (log)
2431             log->Printf("  \"%s\" (\"%s\") placed at %" PRId64,
2432                         name.GetCString(),
2433                         decl->getNameAsString().c_str(),
2434                         offset);
2435
2436         if (value)
2437         {
2438             if (log)
2439                 log->Printf("    Replacing [%s]", PrintValue(value).c_str());
2440
2441             FunctionValueCache body_result_maker ([this, name, offset_type, offset, argument, value] (llvm::Function *function)->llvm::Value * {
2442                 // Per the comment at ASTResultSynthesizer::SynthesizeBodyResult, in cases where the result
2443                 // variable is an rvalue, we have to synthesize a dereference of the appropriate structure
2444                 // entry in order to produce the static variable that the AST thinks it is accessing.
2445
2446                 llvm::Instruction *entry_instruction = llvm::cast<Instruction>(m_entry_instruction_finder.GetValue(function));
2447
2448                 ConstantInt *offset_int(ConstantInt::get(offset_type, offset, true));
2449                 GetElementPtrInst *get_element_ptr = GetElementPtrInst::Create(argument,
2450                                                                                offset_int,
2451                                                                                "",
2452                                                                                entry_instruction);
2453
2454                 if (name == m_result_name && !m_result_is_pointer)
2455                 {
2456                     BitCastInst *bit_cast = new BitCastInst(get_element_ptr,
2457                                                             value->getType()->getPointerTo(),
2458                                                             "",
2459                                                             entry_instruction);
2460
2461                     LoadInst *load = new LoadInst(bit_cast, "", entry_instruction);
2462
2463                     return load;
2464                 }
2465                 else
2466                 {
2467                     BitCastInst *bit_cast = new BitCastInst(get_element_ptr, value->getType(), "", entry_instruction);
2468
2469                     return bit_cast;
2470                 }
2471             });
2472
2473             if (Constant *constant = dyn_cast<Constant>(value))
2474             {
2475                 UnfoldConstant(constant, body_result_maker, m_entry_instruction_finder);
2476             }
2477             else if (Instruction *instruction = dyn_cast<Instruction>(value))
2478             {
2479                 value->replaceAllUsesWith(body_result_maker.GetValue(instruction->getParent()->getParent()));
2480             }
2481             else
2482             {
2483                 if (log)
2484                     log->Printf("Unhandled non-constant type: \"%s\"", PrintValue(value).c_str());
2485                 return false;
2486             }
2487
2488             if (GlobalVariable *var = dyn_cast<GlobalVariable>(value))
2489                 var->eraseFromParent();
2490         }
2491     }
2492
2493     if (log)
2494         log->Printf("Total structure [align %" PRId64 ", size %zu]", alignment, size);
2495
2496     return true;
2497 }
2498
2499 llvm::Constant *
2500 IRForTarget::BuildRelocation(llvm::Type *type, uint64_t offset)
2501 {
2502     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
2503                                              (m_module->getPointerSize() == Module::Pointer64) ? 64 : 32);
2504
2505     llvm::Constant *offset_int = ConstantInt::get(intptr_ty, offset);
2506
2507     llvm::Constant *offset_array[1];
2508
2509     offset_array[0] = offset_int;
2510
2511     llvm::ArrayRef<llvm::Constant *> offsets(offset_array, 1);
2512
2513     llvm::Constant *reloc_getelementptr = ConstantExpr::getGetElementPtr(m_reloc_placeholder, offsets);
2514     llvm::Constant *reloc_getbitcast = ConstantExpr::getBitCast(reloc_getelementptr, type);
2515
2516     return reloc_getbitcast;
2517 }
2518
2519 bool
2520 IRForTarget::CompleteDataAllocation ()
2521 {
2522     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2523
2524     if (!m_data_allocator.GetStream().GetSize())
2525         return true;
2526
2527     lldb::addr_t allocation = m_data_allocator.Allocate();
2528
2529     if (log)
2530     {
2531         if (allocation)
2532             log->Printf("Allocated static data at 0x%llx", (unsigned long long)allocation);
2533         else
2534             log->Printf("Failed to allocate static data");
2535     }
2536
2537     if (!allocation || allocation == LLDB_INVALID_ADDRESS)
2538         return false;
2539
2540     IntegerType *intptr_ty = Type::getIntNTy(m_module->getContext(),
2541                                              (m_module->getPointerSize() == Module::Pointer64) ? 64 : 32);
2542
2543     Constant *relocated_addr = ConstantInt::get(intptr_ty, (uint64_t)allocation);
2544     Constant *relocated_bitcast = ConstantExpr::getIntToPtr(relocated_addr, llvm::Type::getInt8PtrTy(m_module->getContext()));
2545
2546     m_reloc_placeholder->replaceAllUsesWith(relocated_bitcast);
2547
2548     m_reloc_placeholder->eraseFromParent();
2549
2550     return true;
2551 }
2552
2553 bool
2554 IRForTarget::StripAllGVs (Module &llvm_module)
2555 {
2556     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2557     std::vector<GlobalVariable *> global_vars;
2558     std::set<GlobalVariable *>erased_vars;
2559
2560     bool erased = true;
2561
2562     while (erased)
2563     {
2564         erased = false;
2565
2566         for (Module::global_iterator gi = llvm_module.global_begin(), ge = llvm_module.global_end();
2567              gi != ge;
2568              ++gi)
2569         {
2570             GlobalVariable *global_var = dyn_cast<GlobalVariable>(gi);
2571
2572             global_var->removeDeadConstantUsers();
2573
2574             if (global_var->use_empty())
2575             {
2576                 if (log)
2577                     log->Printf("Did remove %s",
2578                                 PrintValue(global_var).c_str());
2579                 global_var->eraseFromParent();
2580                 erased = true;
2581                 break;
2582             }
2583         }
2584     }
2585
2586     for (Module::global_iterator gi = llvm_module.global_begin(), ge = llvm_module.global_end();
2587          gi != ge;
2588          ++gi)
2589     {
2590         GlobalVariable *global_var = dyn_cast<GlobalVariable>(gi);
2591
2592         GlobalValue::use_iterator ui = global_var->use_begin();
2593
2594         if (log)
2595             log->Printf("Couldn't remove %s because of %s",
2596                         PrintValue(global_var).c_str(),
2597                         PrintValue(*ui).c_str());
2598     }
2599
2600     return true;
2601 }
2602
2603 bool
2604 IRForTarget::runOnModule (Module &llvm_module)
2605 {
2606     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
2607
2608     m_module = &llvm_module;
2609     m_target_data.reset(new DataLayout(m_module));
2610
2611     if (log)
2612     {
2613         std::string s;
2614         raw_string_ostream oss(s);
2615
2616         m_module->print(oss, NULL);
2617
2618         oss.flush();
2619
2620         log->Printf("Module as passed in to IRForTarget: \n\"%s\"", s.c_str());
2621     }
2622
2623     Function* main_function = m_module->getFunction(StringRef(m_func_name.c_str()));
2624
2625     if (!main_function)
2626     {
2627         if (log)
2628             log->Printf("Couldn't find \"%s()\" in the module", m_func_name.c_str());
2629
2630         if (m_error_stream)
2631             m_error_stream->Printf("Internal error [IRForTarget]: Couldn't find wrapper '%s' in the module", m_func_name.c_str());
2632
2633         return false;
2634     }
2635
2636     if (!FixFunctionLinkage (*main_function))
2637     {
2638         if (log)
2639             log->Printf("Couldn't fix the linkage for the function");
2640
2641         return false;
2642     }
2643
2644     llvm::Type *intptr_ty = Type::getInt8Ty(m_module->getContext());
2645
2646     m_reloc_placeholder = new llvm::GlobalVariable((*m_module),
2647                                                    intptr_ty,
2648                                                    false /* IsConstant */,
2649                                                    GlobalVariable::InternalLinkage,
2650                                                    Constant::getNullValue(intptr_ty),
2651                                                    "reloc_placeholder",
2652                                                    NULL /* InsertBefore */,
2653                                                    GlobalVariable::NotThreadLocal /* ThreadLocal */,
2654                                                    0 /* AddressSpace */);
2655
2656     ////////////////////////////////////////////////////////////
2657     // Replace $__lldb_expr_result with a persistent variable
2658     //
2659
2660     if (!CreateResultVariable(*main_function))
2661     {
2662         if (log)
2663             log->Printf("CreateResultVariable() failed");
2664
2665         // CreateResultVariable() reports its own errors, so we don't do so here
2666
2667         return false;
2668     }
2669
2670     if (log && log->GetVerbose())
2671     {
2672         std::string s;
2673         raw_string_ostream oss(s);
2674
2675         m_module->print(oss, NULL);
2676
2677         oss.flush();
2678
2679         log->Printf("Module after creating the result variable: \n\"%s\"", s.c_str());
2680     }
2681
2682     for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2683          fi != fe;
2684          ++fi)
2685     {
2686         llvm::Function *function = fi;
2687
2688         if (function->begin() == function->end())
2689             continue;
2690
2691         Function::iterator bbi;
2692
2693         for (bbi = function->begin();
2694              bbi != function->end();
2695              ++bbi)
2696         {
2697             if (!RemoveGuards(*bbi))
2698             {
2699                 if (log)
2700                     log->Printf("RemoveGuards() failed");
2701
2702                 // RemoveGuards() reports its own errors, so we don't do so here
2703
2704                 return false;
2705             }
2706
2707             if (!RewritePersistentAllocs(*bbi))
2708             {
2709                 if (log)
2710                     log->Printf("RewritePersistentAllocs() failed");
2711
2712                 // RewritePersistentAllocs() reports its own errors, so we don't do so here
2713
2714                 return false;
2715             }
2716
2717             if (!RemoveCXAAtExit(*bbi))
2718             {
2719                 if (log)
2720                     log->Printf("RemoveCXAAtExit() failed");
2721
2722                 // RemoveCXAAtExit() reports its own errors, so we don't do so here
2723
2724                 return false;
2725             }
2726         }
2727     }
2728
2729     ///////////////////////////////////////////////////////////////////////////////
2730     // Fix all Objective-C constant strings to use NSStringWithCString:encoding:
2731     //
2732
2733     if (!RewriteObjCConstStrings())
2734     {
2735         if (log)
2736             log->Printf("RewriteObjCConstStrings() failed");
2737
2738         // RewriteObjCConstStrings() reports its own errors, so we don't do so here
2739
2740         return false;
2741     }
2742
2743     ///////////////////////////////
2744     // Resolve function pointers
2745     //
2746
2747     if (!ResolveFunctionPointers(llvm_module))
2748     {
2749         if (log)
2750             log->Printf("ResolveFunctionPointers() failed");
2751
2752         // ResolveFunctionPointers() reports its own errors, so we don't do so here
2753
2754         return false;
2755     }
2756
2757     for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2758          fi != fe;
2759          ++fi)
2760     {
2761         llvm::Function *function = fi;
2762
2763         for (llvm::Function::iterator bbi = function->begin(), bbe = function->end();
2764              bbi != bbe;
2765              ++bbi)
2766         {
2767             if (!RewriteObjCSelectors(*bbi))
2768             {
2769                 if (log)
2770                     log->Printf("RewriteObjCSelectors() failed");
2771
2772                 // RewriteObjCSelectors() reports its own errors, so we don't do so here
2773
2774                 return false;
2775             }
2776         }
2777     }
2778
2779     for (Module::iterator fi = m_module->begin(), fe = m_module->end();
2780          fi != fe;
2781          ++fi)
2782     {
2783         llvm::Function *function = fi;
2784
2785         for (llvm::Function::iterator bbi = function->begin(), bbe = function->end();
2786              bbi != bbe;
2787              ++bbi)
2788         {
2789             if (!ResolveCalls(*bbi))
2790             {
2791                 if (log)
2792                     log->Printf("ResolveCalls() failed");
2793
2794                 // ResolveCalls() reports its own errors, so we don't do so here
2795
2796                 return false;
2797             }
2798
2799             if (!ReplaceStaticLiterals(*bbi))
2800             {
2801                 if (log)
2802                     log->Printf("ReplaceStaticLiterals() failed");
2803
2804                 return false;
2805             }
2806         }
2807     }
2808
2809     ////////////////////////////////////////////////////////////////////////
2810     // Run function-level passes that only make sense on the main function
2811     //
2812
2813     if (!ResolveExternals(*main_function))
2814     {
2815         if (log)
2816             log->Printf("ResolveExternals() failed");
2817
2818         // ResolveExternals() reports its own errors, so we don't do so here
2819
2820         return false;
2821     }
2822
2823     if (!ReplaceVariables(*main_function))
2824     {
2825         if (log)
2826             log->Printf("ReplaceVariables() failed");
2827
2828         // ReplaceVariables() reports its own errors, so we don't do so here
2829
2830         return false;
2831     }
2832
2833     if (!ReplaceStrings())
2834     {
2835         if (log)
2836             log->Printf("ReplaceStrings() failed");
2837
2838         return false;
2839     }
2840
2841     if (!CompleteDataAllocation())
2842     {
2843         if (log)
2844             log->Printf("CompleteDataAllocation() failed");
2845
2846         return false;
2847     }
2848
2849     if (!StripAllGVs(llvm_module))
2850     {
2851         if (log)
2852             log->Printf("StripAllGVs() failed");
2853     }
2854
2855     if (log && log->GetVerbose())
2856     {
2857         std::string s;
2858         raw_string_ostream oss(s);
2859
2860         m_module->print(oss, NULL);
2861
2862         oss.flush();
2863
2864         log->Printf("Module after preparing for execution: \n\"%s\"", s.c_str());
2865     }
2866
2867     return true;
2868 }
2869
2870 void
2871 IRForTarget::assignPassManager (PMStack &pass_mgr_stack, PassManagerType pass_mgr_type)
2872 {
2873 }
2874
2875 PassManagerType
2876 IRForTarget::getPotentialPassManagerType() const
2877 {
2878     return PMT_ModulePassManager;
2879 }