remove trailing whitespace + remove some useless comments

llvm-svn: 212411

1 files changed, 116 insertions, 120 deletions

diff --git a/lldb/source/Expression/IRExecutionUnit.cpp b/lldb/source/Expression/IRExecutionUnit.cpp
index 90d8d76cd55..76956082da0 100644
--- a/lldb/source/Expression/IRExecutionUnit.cpp
+++ b/lldb/source/Expression/IRExecutionUnit.cpp
@@ -7,14 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/SourceMgr.h"
-// Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Disassembler.h"
@@ -48,39 +44,39 @@ lldb::addr_t
 IRExecutionUnit::WriteNow (const uint8_t *bytes,
                            size_t size,
                            Error &error)
-{    
+{
     lldb::addr_t allocation_process_addr = Malloc (size,
                                                    8,
                                                    lldb::ePermissionsWritable | lldb::ePermissionsReadable,
                                                    eAllocationPolicyMirror,
                                                    error);
-    
+
     if (!error.Success())
         return LLDB_INVALID_ADDRESS;
-    
+
     WriteMemory(allocation_process_addr, bytes, size, error);
-    
+
     if (!error.Success())
     {
         Error err;
         Free (allocation_process_addr, err);
-        
+
         return LLDB_INVALID_ADDRESS;
     }
-    
+
     if (Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
     {
         DataBufferHeap my_buffer(size, 0);
         Error err;
         ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
-        
+
         if (err.Success())
         {
             DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
             my_extractor.PutToLog(log, 0, my_buffer.GetByteSize(), allocation_process_addr, 16, DataExtractor::TypeUInt8);
         }
     }
-    
+
     return allocation_process_addr;
 }
 
@@ -89,9 +85,9 @@ IRExecutionUnit::FreeNow (lldb::addr_t allocation)
 {
     if (allocation == LLDB_INVALID_ADDRESS)
         return;
-    
+
     Error err;
-    
+
     Free(allocation, err);
 }
 
@@ -100,16 +96,16 @@ IRExecutionUnit::DisassembleFunction (Stream &stream,
                                       lldb::ProcessSP &process_wp)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    
+
     ExecutionContext exe_ctx(process_wp);
-        
+
     Error ret;
-    
+
     ret.Clear();
-    
+
     lldb::addr_t func_local_addr = LLDB_INVALID_ADDRESS;
     lldb::addr_t func_remote_addr = LLDB_INVALID_ADDRESS;
-        
+
     for (JittedFunction &function : m_jitted_functions)
     {
         if (strstr(function.m_name.c_str(), m_name.AsCString()))
@@ -118,31 +114,31 @@ IRExecutionUnit::DisassembleFunction (Stream &stream,
             func_remote_addr = function.m_remote_addr;
         }
     }
-    
+
     if (func_local_addr == LLDB_INVALID_ADDRESS)
     {
         ret.SetErrorToGenericError();
         ret.SetErrorStringWithFormat("Couldn't find function %s for disassembly", m_name.AsCString());
         return ret;
     }
-    
+
     if (log)
         log->Printf("Found function, has local address 0x%" PRIx64 " and remote address 0x%" PRIx64, (uint64_t)func_local_addr, (uint64_t)func_remote_addr);
-    
+
     std::pair <lldb::addr_t, lldb::addr_t> func_range;
-    
+
     func_range = GetRemoteRangeForLocal(func_local_addr);
-    
+
     if (func_range.first == 0 && func_range.second == 0)
     {
         ret.SetErrorToGenericError();
         ret.SetErrorStringWithFormat("Couldn't find code range for function %s", m_name.AsCString());
         return ret;
     }
-    
+
     if (log)
         log->Printf("Function's code range is [0x%" PRIx64 "+0x%" PRIx64 "]", func_range.first, func_range.second);
-    
+
     Target *target = exe_ctx.GetTargetPtr();
     if (!target)
     {
@@ -150,44 +146,44 @@ IRExecutionUnit::DisassembleFunction (Stream &stream,
         ret.SetErrorString("Couldn't find the target");
         return ret;
     }
-    
+
     lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
-    
+
     Process *process = exe_ctx.GetProcessPtr();
     Error err;
     process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), err);
-    
+
     if (!err.Success())
     {
         ret.SetErrorToGenericError();
         ret.SetErrorStringWithFormat("Couldn't read from process: %s", err.AsCString("unknown error"));
         return ret;
     }
-    
+
     ArchSpec arch(target->GetArchitecture());
-    
+
     const char *plugin_name = NULL;
     const char *flavor_string = NULL;
     lldb::DisassemblerSP disassembler_sp = Disassembler::FindPlugin(arch, flavor_string, plugin_name);
-    
+
     if (!disassembler_sp)
     {
         ret.SetErrorToGenericError();
         ret.SetErrorStringWithFormat("Unable to find disassembler plug-in for %s architecture.", arch.GetArchitectureName());
         return ret;
     }
-    
+
     if (!process)
     {
         ret.SetErrorToGenericError();
         ret.SetErrorString("Couldn't find the process");
         return ret;
     }
-    
+
     DataExtractor extractor(buffer_sp,
                             process->GetByteOrder(),
                             target->GetArchitecture().GetAddressByteSize());
-    
+
     if (log)
     {
         log->Printf("Function data has contents:");
@@ -198,12 +194,12 @@ IRExecutionUnit::DisassembleFunction (Stream &stream,
                             16,
                             DataExtractor::TypeUInt8);
     }
-    
+
     disassembler_sp->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false);
-    
+
     InstructionList &instruction_list = disassembler_sp->GetInstructionList();
     const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();
-    
+
     for (size_t instruction_index = 0, num_instructions = instruction_list.GetSize();
          instruction_index < num_instructions;
          ++instruction_index)
@@ -225,7 +221,7 @@ IRExecutionUnit::DisassembleFunction (Stream &stream,
 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic, void *Context, unsigned LocCookie)
 {
     Error *err = static_cast<Error*>(Context);
-    
+
     if (err && err->Success())
     {
         err->SetErrorToGenericError();
@@ -239,52 +235,52 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
                                  lldb::addr_t &func_end)
 {
     lldb::ProcessSP process_sp(GetProcessWP().lock());
-    
+
     static Mutex s_runnable_info_mutex(Mutex::Type::eMutexTypeRecursive);
-    
+
     func_addr = LLDB_INVALID_ADDRESS;
     func_end = LLDB_INVALID_ADDRESS;
-    
+
     if (!process_sp)
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Couldn't write the JIT compiled code into the process because the process is invalid");
         return;
     }
-    
+
     if (m_did_jit)
     {
         func_addr = m_function_load_addr;
         func_end = m_function_end_load_addr;
-        
+
         return;
     };
-    
+
     Mutex::Locker runnable_info_mutex_locker(s_runnable_info_mutex);
-    
+
     m_did_jit = true;
-    
+
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    
+
     std::string error_string;
-    
+
     if (log)
     {
         std::string s;
         llvm::raw_string_ostream oss(s);
-        
+
         m_module->print(oss, NULL);
-        
+
         oss.flush();
-        
+
         log->Printf ("Module being sent to JIT: \n%s", s.c_str());
     }
-    
+
     llvm::Triple triple(m_module->getTargetTriple());
     llvm::Function *function = m_module->getFunction (m_name.AsCString());
     llvm::Reloc::Model relocModel;
     llvm::CodeModel::Model codeModel;
-    
+
     if (triple.isOSBinFormatELF())
     {
         relocModel = llvm::Reloc::Static;
@@ -296,11 +292,11 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
         relocModel = llvm::Reloc::PIC_;
         codeModel = llvm::CodeModel::Small;
     }
-    
+
     m_module_ap->getContext().setInlineAsmDiagnosticHandler(ReportInlineAsmError, &error);
-    
+
     llvm::EngineBuilder builder(m_module_ap.get());
-    
+
     builder.setEngineKind(llvm::EngineKind::JIT)
     .setErrorStr(&error_string)
     .setRelocationModel(relocModel)
@@ -309,21 +305,21 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
     .setAllocateGVsWithCode(true)
     .setCodeModel(codeModel)
     .setUseMCJIT(true);
-    
+
     llvm::StringRef mArch;
     llvm::StringRef mCPU;
     llvm::SmallVector<std::string, 0> mAttrs;
-    
+
     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));
-    
+
     if (!m_execution_engine_ap.get())
     {
         error.SetErrorToGenericError();
@@ -334,46 +330,46 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
     {
         m_module_ap.release(); // ownership was transferred
     }
-    
+
     // Make sure we see all sections, including ones that don't have relocations...
     m_execution_engine_ap->setProcessAllSections(true);
-    
+
     m_execution_engine_ap->DisableLazyCompilation();
-    
+
     // We don't actually need the function pointer here, this just forces it to get resolved.
-    
+
     void *fun_ptr = m_execution_engine_ap->getPointerToFunction(function);
-    
+
     if (!error.Success())
     {
         // We got an error through our callback!
         return;
     }
-    
+
     if (!function)
     {
         error.SetErrorToGenericError();
         error.SetErrorStringWithFormat("Couldn't find '%s' in the JITted module", m_name.AsCString());
         return;
     }
-    
+
     if (!fun_ptr)
     {
         error.SetErrorToGenericError();
         error.SetErrorStringWithFormat("'%s' was in the JITted module but wasn't lowered", m_name.AsCString());
         return;
     }
-    
+
     m_jitted_functions.push_back (JittedFunction(m_name.AsCString(), (lldb::addr_t)fun_ptr));
-    
+
     CommitAllocations(process_sp);
     ReportAllocations(*m_execution_engine_ap);
     WriteData(process_sp);
-            
+
     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()))
         {
             AddrRange func_range = GetRemoteRangeForLocal(jitted_function.m_local_addr);
@@ -381,15 +377,15 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
             m_function_load_addr = jitted_function.m_remote_addr;
         }
     }
-    
+
     if (log)
     {
         log->Printf("Code can be run in the target.");
-        
+
         StreamString disassembly_stream;
-        
+
         Error err = DisassembleFunction(disassembly_stream, process_sp);
-        
+
         if (!err.Success())
         {
             log->Printf("Couldn't disassemble function : %s", err.AsCString("unknown error"));
@@ -398,18 +394,18 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
         {
             log->Printf("Function disassembly:\n%s", disassembly_stream.GetData());
         }
-        
+
         log->Printf("Sections: ");
         for (AllocationRecord &record : m_records)
         {
             if (record.m_process_address != LLDB_INVALID_ADDRESS)
             {
                 record.dump(log);
-                
+
                 DataBufferHeap my_buffer(record.m_size, 0);
                 Error err;
                 ReadMemory(my_buffer.GetBytes(), record.m_process_address, record.m_size, err);
-                
+
                 if (err.Success())
                 {
                     DataExtractor my_extractor(my_buffer.GetBytes(), my_buffer.GetByteSize(), lldb::eByteOrderBig, 8);
@@ -418,10 +414,10 @@ IRExecutionUnit::GetRunnableInfo(Error &error,
             }
         }
     }
-    
+
     func_addr = m_function_load_addr;
     func_end = m_function_end_load_addr;
-    
+
     return;
 }
 
@@ -508,7 +504,7 @@ IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRE
         case AllocationKind::Global:sect_type = lldb::eSectionTypeData; break;
         case AllocationKind::Bytes: sect_type = lldb::eSectionTypeOther; break;
     }
-    
+
     if (!name.empty())
     {
         if (name.equals("__text") || name.equals(".text"))
@@ -527,46 +523,46 @@ IRExecutionUnit::GetSectionTypeFromSectionName (const llvm::StringRef &name, IRE
                     else if (dwarf_name.equals("aranges"))
                         sect_type = lldb::eSectionTypeDWARFDebugAranges;
                     break;
-                    
+
                 case 'f':
                     if (dwarf_name.equals("frame"))
                         sect_type = lldb::eSectionTypeDWARFDebugFrame;
                     break;
-                    
+
                 case 'i':
                     if (dwarf_name.equals("info"))
                         sect_type = lldb::eSectionTypeDWARFDebugInfo;
                     break;
-                    
+
                 case 'l':
                     if (dwarf_name.equals("line"))
                         sect_type = lldb::eSectionTypeDWARFDebugLine;
                     else if (dwarf_name.equals("loc"))
                         sect_type = lldb::eSectionTypeDWARFDebugLoc;
                     break;
-                    
+
                 case 'm':
                     if (dwarf_name.equals("macinfo"))
                         sect_type = lldb::eSectionTypeDWARFDebugMacInfo;
                     break;
-                    
+
                 case 'p':
                     if (dwarf_name.equals("pubnames"))
                         sect_type = lldb::eSectionTypeDWARFDebugPubNames;
                     else if (dwarf_name.equals("pubtypes"))
                         sect_type = lldb::eSectionTypeDWARFDebugPubTypes;
                     break;
-                    
+
                 case 's':
                     if (dwarf_name.equals("str"))
                         sect_type = lldb::eSectionTypeDWARFDebugStr;
                     break;
-                    
+
                 case 'r':
                     if (dwarf_name.equals("ranges"))
                         sect_type = lldb::eSectionTypeDWARFDebugRanges;
                     break;
-                    
+
                 default:
                     break;
             }
@@ -611,7 +607,7 @@ IRExecutionUnit::MemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     uint8_t *return_value = m_default_mm_ap->allocateSpace(Size, Alignment);
-    
+
     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
                                                   lldb::ePermissionsReadable | lldb::ePermissionsWritable,
                                                   GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Bytes),
@@ -619,13 +615,13 @@ IRExecutionUnit::MemoryManager::allocateSpace(intptr_t Size, unsigned Alignment)
                                                   Alignment,
                                                   eSectionIDInvalid,
                                                   NULL));
-    
+
     if (log)
     {
         log->Printf("IRExecutionUnit::allocateSpace(Size=%" PRIu64 ", Alignment=%u) = %p",
                                (uint64_t)Size, Alignment, return_value);
     }
-        
+
     return return_value;
 }
 
@@ -636,9 +632,9 @@ IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size,
                                                     llvm::StringRef SectionName)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    
+
     uint8_t *return_value = m_default_mm_ap->allocateCodeSection(Size, Alignment, SectionID, SectionName);
-    
+
     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
                                                   lldb::ePermissionsReadable | lldb::ePermissionsExecutable,
                                                   GetSectionTypeFromSectionName (SectionName, AllocationKind::Code),
@@ -646,13 +642,13 @@ IRExecutionUnit::MemoryManager::allocateCodeSection(uintptr_t Size,
                                                   Alignment,
                                                   SectionID,
                                                   SectionName.str().c_str()));
-    
+
     if (log)
     {
         log->Printf("IRExecutionUnit::allocateCodeSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
                     (uint64_t)Size, Alignment, SectionID, return_value);
     }
-        
+
     return return_value;
 }
 
@@ -666,7 +662,7 @@ IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size,
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
-    
+
     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
                                                   lldb::ePermissionsReadable | (IsReadOnly ? 0 : lldb::ePermissionsWritable),
                                                   GetSectionTypeFromSectionName (SectionName, AllocationKind::Data),
@@ -679,8 +675,8 @@ IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size,
         log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",
                     (uint64_t)Size, Alignment, SectionID, return_value);
     }
-        
-    return return_value; 
+
+    return return_value;
 }
 
 uint8_t *
@@ -690,7 +686,7 @@ IRExecutionUnit::MemoryManager::allocateGlobal(uintptr_t Size,
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     uint8_t *return_value = m_default_mm_ap->allocateGlobal(Size, Alignment);
-    
+
     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
                                                   lldb::ePermissionsReadable | lldb::ePermissionsWritable,
                                                   GetSectionTypeFromSectionName (llvm::StringRef(), AllocationKind::Global),
@@ -698,13 +694,13 @@ IRExecutionUnit::MemoryManager::allocateGlobal(uintptr_t Size,
                                                   Alignment,
                                                   eSectionIDInvalid,
                                                   NULL));
-    
+
     if (log)
     {
         log->Printf("IRExecutionUnit::allocateGlobal(Size=0x%" PRIx64 ", Alignment=%u) = %p",
                     (uint64_t)Size, Alignment, return_value);
     }
-    
+
     return return_value;
 }
 
@@ -726,9 +722,9 @@ IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
         {
             if (record.m_process_address == LLDB_INVALID_ADDRESS)
                 return LLDB_INVALID_ADDRESS;
-            
+
             lldb::addr_t ret = record.m_process_address + (local_address - record.m_host_address);
-            
+
             if (log)
             {
                 log->Printf("IRExecutionUnit::GetRemoteAddressForLocal() found 0x%" PRIx64 " in [0x%" PRIx64 "..0x%" PRIx64 "], and returned 0x%" PRIx64 " from [0x%" PRIx64 "..0x%" PRIx64 "].",
@@ -739,7 +735,7 @@ IRExecutionUnit::GetRemoteAddressForLocal (lldb::addr_t local_address)
                             record.m_process_address,
                             record.m_process_address + record.m_size);
             }
-            
+
             return ret;
         }
     }
@@ -757,11 +753,11 @@ IRExecutionUnit::GetRemoteRangeForLocal (lldb::addr_t local_address)
         {
             if (record.m_process_address == LLDB_INVALID_ADDRESS)
                 return AddrRange(0, 0);
-            
+
             return AddrRange(record.m_process_address, record.m_size);
         }
     }
-    
+
     return AddrRange (0, 0);
 }
 
@@ -769,14 +765,14 @@ bool
 IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp)
 {
     bool ret = true;
-    
+
     lldb_private::Error err;
-    
+
     for (AllocationRecord &record : m_records)
     {
         if (record.m_process_address != LLDB_INVALID_ADDRESS)
             continue;
-        
+
         switch (record.m_sect_type)
         {
         case lldb::eSectionTypeInvalid:
@@ -805,14 +801,14 @@ IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp)
                                                err);
             break;
         }
-        
+
         if (!err.Success())
         {
             ret = false;
             break;
         }
     }
-    
+
     if (!ret)
     {
         for (AllocationRecord &record : m_records)
@@ -824,7 +820,7 @@ IRExecutionUnit::CommitAllocations (lldb::ProcessSP &process_sp)
             }
         }
     }
-    
+
     return ret;
 }
 
@@ -835,13 +831,13 @@ IRExecutionUnit::ReportAllocations (llvm::ExecutionEngine &engine)
     {
         if (record.m_process_address == LLDB_INVALID_ADDRESS)
             continue;
-        
+
         if (record.m_section_id == eSectionIDInvalid)
             continue;
-        
+
         engine.mapSectionAddress((void*)record.m_host_address, record.m_process_address);
     }
-    
+
     // Trigger re-application of relocations.
     engine.finalizeObject();
 }
@@ -863,12 +859,12 @@ IRExecutionUnit::WriteData (lldb::ProcessSP &process_sp)
     return wrote_something;
 }
 
-void 
+void
 IRExecutionUnit::AllocationRecord::dump (Log *log)
 {
     if (!log)
         return;
-    
+
     log->Printf("[0x%llx+0x%llx]->0x%llx (alignment %d, section ID %d)",
                 (unsigned long long)m_host_address,
                 (unsigned long long)m_size,