Fix TestCStrings for Linux with i386 inferiors.

[chaoren]

Summary

Temporarily revert part of r261704.

[chaoren]

Use target instead of sc.target_sp.get().

source/Expression/IRExecutionUnit.cpp

if (log)
                             16,
                             DataExtractor::TypeUInt8);
     }
 
     disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false);
 
     InstructionList &instruction_list = disassembler_sp->GetInstructionList();
     instruction_list.Dump(&stream, true, true, &exe_ctx);
-    
     // FIXME: The DisassemblerLLVMC has a reference cycle and won't go away if it has any active instructions.
     // I'll fix that but for now, just clear the list and it will go away nicely.
     disassembler_sp->GetInstructionList().Clear();
     return ret;
 }
 
 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie)
 {
IRExecutionUnit::GetRunnableInfo(Error &error,
     if (triple.isOSBinFormatELF())
     {
         relocModel = llvm::Reloc::Static;
     }
     else
     {
         relocModel = llvm::Reloc::PIC_;
     }
-    
     // This will be small for 32-bit and large for 64-bit.
     codeModel = llvm::CodeModel::JITDefault;
 
     m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error);
 
     llvm::EngineBuilder builder(std::move(m_module_ap));
 
     builder.setEngineKind(llvm::EngineKind::JIT)
for (std::string &feature : m_cpu_features)
         mAttrs.push_back(feature);
 
     llvm::TargetMachine *target_machine = builder.selectTarget(triple,
                                                                mArch,
                                                                mCPU,
                                                                mAttrs);
 
     m_execution_engine_ap.reset(builder.create(target_machine));
-    
     m_strip_underscore = (m_execution_engine_ap->getDataLayout().getGlobalPrefix() == '_');
 
     if (!m_execution_engine_ap.get())
     {
         error.SetErrorToGenericError();
         error.SetErrorStringWithFormat("Couldn't JIT the function: %s", error_string.c_str());
         return;
     }
IRExecutionUnit::GetRunnableInfo(Error &error,
 
     CommitAllocations(process_sp);
     ReportAllocations(*m_execution_engine_ap);
     WriteData(process_sp);
 
     if (m_failed_lookups.size())
     {
         StreamString ss;
-        
         ss.PutCString("Couldn't lookup symbols:\n");
-        
         bool emitNewLine = false;
-        
         for (const ConstString &failed_lookup : m_failed_lookups)
         {
             if (emitNewLine)
                 ss.PutCString("\n");
             emitNewLine = true;
             ss.PutCString("  ");
             ss.PutCString(Mangled(failed_lookup).GetDemangledName(lldb::eLanguageTypeObjC_plus_plus).AsCString());
         }
-        
         m_failed_lookups.clear();
-        
         error.SetErrorString(ss.GetData());
-        
         return;
     }
-    
     m_function_load_addr = LLDB_INVALID_ADDRESS;
     m_function_end_load_addr = LLDB_INVALID_ADDRESS;
 
     for (JittedFunction &jitted_function : m_jitted_functions)
     {
         jitted_function.m_remote_addr = GetRemoteAddressForLocal (jitted_function.m_local_addr);
 
         if (!jitted_function.m_name.compare(m_name.AsCString()))
if (log)
                 {
                     DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
                     my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), record.m_process_address, 16, DataExtractor::TypeUInt8);
                 }
             }
             else
             {
                 record.dump(log);
-                
                 DataExtractor my_extractor ((const void*)record.m_host_address, record.m_size, lldb::eByteOrderBig, 8);
                 my_extractor.PutToLog(log, 0, record.m_size, record.m_host_address, 16, DataExtractor::TypeUInt8);
             }
         }
     }
 
     func_addr = m_function_load_addr;
     func_end = m_function_end_load_addr;
IRExecutionUnit::CollectCandidateCPlusPlusNames(std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, const std::vector<SearchSpec> &C_specs, const SymbolContext &sc)
     for (const SearchSpec &C_spec : C_specs)
     {
         const ConstString &name = C_spec.name;
 
         if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString()))
         {
             Mangled mangled(name, true);
             ConstString demangled = mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
-            
             if (demangled)
             {
                 ConstString best_alternate_mangled_name = FindBestAlternateMangledName(demangled, lldb::eLanguageTypeC_plus_plus, sc);
-                
                 if (best_alternate_mangled_name)
                 {
                     CPP_specs.push_back(best_alternate_mangled_name);
                 }
-                
                 CPP_specs.push_back(SearchSpec(demangled, lldb::eFunctionNameTypeFull));
             }
         }
-        
         // Maybe we're looking for a const symbol but the debug info told us it was const...
         if (!strncmp(name.GetCString(), "_ZN", 3) &&
             strncmp(name.GetCString(), "_ZNK", 4))
         {
             std::string fixed_scratch("_ZNK");
             fixed_scratch.append(name.GetCString() + 3);
             CPP_specs.push_back(ConstString(fixed_scratch.c_str()));
         }
-        
         // Maybe we're looking for a static symbol but we thought it was global...
         if (!strncmp(name.GetCString(), "_Z", 2) &&
             strncmp(name.GetCString(), "_ZL", 3))
         {
             std::string fixed_scratch("_ZL");
             fixed_scratch.append(name.GetCString() + 2);
             CPP_specs.push_back(ConstString(fixed_scratch.c_str()));
         }
for (const SearchSpec &spec : specs)
             {
                 SymbolContext candidate_sc;
 
                 sc_list.GetContextAtIndex(si, candidate_sc);
 
                 const bool is_external = (candidate_sc.function) ||
                                          (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
 
-                AddressRange range;
+                load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
 
-                if (candidate_sc.GetAddressRange(lldb::eSymbolContextFunction | lldb::eSymbolContextSymbol,
-                                                 0,
-                                                 false,
-                                                 range))
-                {
-                    load_address = range.GetBaseAddress().GetCallableLoadAddress(target);
+                if (load_address == LLDB_INVALID_ADDRESS)
+                    load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(sc.target_sp.get());
 
-                    if (load_address != LLDB_INVALID_ADDRESS)
-                    {
-                        if (is_external)
-                        {
-                            return true;
-                        }
-                        else if (best_internal_load_address == LLDB_INVALID_ADDRESS)
-                        {
-                            best_internal_load_address = load_address;
-                            load_address = LLDB_INVALID_ADDRESS;
-                        }
-                    }
-                }
-            }
 
             return false;
         };
-        
         if (sc.module_sp)
         {
             sc.module_sp->FindFunctions(spec.name,
                                         NULL,
                                         spec.mask,
                                         true,  // include_symbols
                                         false, // include_inlines
                                         true,  // append
                                         sc_list);
         }
 
         lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
 
         if (get_external_load_address(load_address, sc_list, sc))
         {
             return load_address;
         }
         else
         {
             sc_list.Clear();
         }
-    
         if (sc_list.GetSize() == 0 && sc.target_sp)
         {
             sc.target_sp->GetImages().FindFunctions(spec.name,
                                                     spec.mask,
                                                     true,  // include_symbols
                                                     false, // include_inlines
                                                     true,  // append
                                                     sc_list);
         }
-        
         if (get_external_load_address(load_address, sc_list, sc))
         {
             return load_address;
         }
         else
         {
             sc_list.Clear();
         }
for (const SearchSpec &spec : specs)
         }
         // if there are any searches we try after this, add an sc_list.Clear() in an "else" clause here
 
         if (best_internal_load_address != LLDB_INVALID_ADDRESS)
         {
             return best_internal_load_address;
         }
     }
-    
     return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t
 IRExecutionUnit::FindInRuntimes(const std::vector<SearchSpec> &specs, const lldb_private::SymbolContext &sc)
 {
     lldb::TargetSP target_sp = sc.target_sp;
-    
     if (!target_sp)
     {
         return LLDB_INVALID_ADDRESS;
     }
-    
     lldb::ProcessSP process_sp = sc.target_sp->GetProcessSP();
-    
     if (!process_sp)
     {
         return LLDB_INVALID_ADDRESS;
     }
 
     ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
 
     if (runtime)
     {
         for (const SearchSpec &spec : specs)
         {
             lldb::addr_t symbol_load_addr = runtime->LookupRuntimeSymbol(spec.name);
-            
             if (symbol_load_addr != LLDB_INVALID_ADDRESS)
                 return symbol_load_addr;
         }
     }
-    
     return LLDB_INVALID_ADDRESS;
 }
 
 lldb::addr_t
 IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name)
 {
     std::vector<SearchSpec> candidate_C_names;
     std::vector<SearchSpec> candidate_CPlusPlus_names;
-    
     CollectCandidateCNames(candidate_C_names, name);
 
     lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx);
     if (ret == LLDB_INVALID_ADDRESS)
         ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
-    
     if (ret == LLDB_INVALID_ADDRESS)
     {
         CollectCandidateCPlusPlusNames(candidate_CPlusPlus_names, candidate_C_names, m_sym_ctx);
         ret = FindInSymbols(candidate_CPlusPlus_names, m_sym_ctx);
     }
-    
     return ret;
 }
 
 uint64_t
 IRExecutionUnit::MemoryManager::getSymbolAddress(const std::string &Name)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     ConstString name_cs(Name.c_str());
-    
     lldb::addr_t ret = m_parent.FindSymbol(name_cs);
-    
     if (ret == LLDB_INVALID_ADDRESS)
     {
         if (log)
             log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = <not found>",
                         Name.c_str());
 
         m_parent.ReportSymbolLookupError(name_cs);
         return 0xbad0bad0;
     }
     else
     {
         if (log)
             log->Printf("IRExecutionUnit::getSymbolAddress(Name=\"%s\") = %" PRIx64,
                         Name.c_str(),
                         ret);
         return ret;
     }
 }
 
 void *
 IRExecutionUnit::MemoryManager::getPointerToNamedFunction(const std::string &Name,
                                                           bool AbortOnFailure) {
     assert (sizeof(void *) == 8);
-    
     return (void*)getSymbolAddress(Name);
 }
 
 lldb::addr_t
 IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));