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