[LLDB] Fix warnings detected by -Wpessimizing-move

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6.

Please check it in if it's OK, because I don't have SVN write access.

[labath]

Looks good. Comitted as r243399. Sorry for the delay.

lldb/trunk/source/API/SBPlatform.cpp

 SBPlatformShellCommand::~SBPlatformShellCommand()
 {
     delete m_opaque_ptr;
 }
 
 void
 SBPlatformShellCommand::Clear()
 {
-    m_opaque_ptr->m_output = std::move(std::string());
+    m_opaque_ptr->m_output = std::string();
     m_opaque_ptr->m_status = 0;
     m_opaque_ptr->m_signo = 0;
 }
 
 const char *
 SBPlatformShellCommand::GetCommand()
 {
     if (m_opaque_ptr->m_command.empty())

lldb/trunk/source/Core/FormatEntity.cpp

for (size_t i=0; i<n; ++i)
         if (key.equals(entry_def->name) || entry_def->name[0] == '*')
         {
             llvm::StringRef value;
             if (sep_char)
                 value = format_str.substr(sep_pos + (entry_def->keep_separator ? 0 : 1));
             switch (entry_def->type)
             {
                 case FormatEntity::Entry::Type::ParentString:
-                    entry.string = std::move(format_str.str());
+                    entry.string = format_str.str();
                     return error; // Success
 
                 case FormatEntity::Entry::Type::ParentNumber:
                     entry.number = entry_def->data;
                     return error; // Success
 
                 case FormatEntity::Entry::Type::InsertString:
                     entry.type = entry_def->type;
for (size_t i=0; i<n; ++i)
                 if (entry_def->children)
                 {
                     error = ParseEntry (value, entry_def, entry);
                 }
                 else if (sep_char == ':')
                 {
                     // Any value whose separator is a with a ':' means this value has a string argument
                     // that needs to be stored in the entry (like "${script.var:modulename.function}")
-                    entry.string = std::move(value.str());
+                    entry.string = value.str();
                 }
                 else
                 {
                     error.SetErrorStringWithFormat("'%s' followed by '%s' but it has no children",
                                                    key.str().c_str(),
                                                    value.str().c_str());
                 }
             }
while (!format.empty() && error.Success())
                         llvm::StringRef variable, variable_format;
                         error = FormatEntity::ExtractVariableInfo (format, variable, variable_format);
                         if (error.Fail())
                             return error;
                         bool verify_is_thread_id = false;
                         Entry entry;
                         if (!variable_format.empty())
                         {
-                            entry.printf_format = std::move(variable_format.str());
+                            entry.printf_format = variable_format.str();
                             
                             // If the format contains a '%' we are going to assume this is
                             // a printf style format. So if you want to format your thread ID
                             // using "0x%llx" you can use:
                             // ${thread.id%0x%llx}
                             //
                             // If there is no '%' in the format, then it is assumed to be a
                             // LLDB format name, or one of the extended formats specified in
FormatEntity::FormatFileSpec (const FileSpec &file_spec, Stream &s, llvm::StringRef variable_name, llvm::StringRef variable_format)
     return false;
 }
 
 static std::string
 MakeMatch (const llvm::StringRef &prefix, const char *suffix)
 {
     std::string match(prefix.str());
     match.append(suffix);
-    return std::move(match);
+    return match;
 }
 
 static void
 AddMatches (const FormatEntity::Entry::Definition *def,
             const llvm::StringRef &prefix,
             const llvm::StringRef &match_prefix,
             StringList &matches)
 {
     const size_t n = def->num_children;
     if (n > 0)
     {
         for (size_t i=0; i<n; ++i)
         {
-            std::string match = std::move(prefix.str());
+            std::string match = prefix.str();
             if (match_prefix.empty())
                 matches.AppendString(MakeMatch (prefix, def->children[i].name));
             else if (strncmp(def->children[i].name, match_prefix.data(), match_prefix.size()) == 0)
                 matches.AppendString(MakeMatch (prefix, def->children[i].name + match_prefix.size()));
         }
     }
 }
 size_t
 FormatEntity::AutoComplete (const char *s,
                             int match_start_point,
                             int max_return_elements,
                             bool &word_complete,
                             StringList &matches)
 {
     word_complete = false;
     llvm::StringRef str(s + match_start_point);
     matches.Clear();
     
     const size_t dollar_pos = str.rfind('$');
     if (dollar_pos != llvm::StringRef::npos)
     {
         // Hitting TAB after $ at the end of the string add a "{"
         if (dollar_pos == str.size() - 1)
         {
-            std::string match = std::move(str.str());
+            std::string match = str.str();
             match.append("{");
             matches.AppendString(std::move(match));
         }
         else if (str[dollar_pos + 1] == '{')
         {
             const size_t close_pos = str.find('}', dollar_pos + 2);
             if (close_pos == llvm::StringRef::npos)
             {
if (dollar_pos != llvm::StringRef::npos)
                             const size_t n = entry_def->num_children;
 
                             if (remainder.empty())
                             {
                                 // Exact match
                                 if (n > 0)
                                 {
                                     // "${thread.info" <TAB>
-                                    matches.AppendString(std::move(MakeMatch (str, ".")));
+                                    matches.AppendString(MakeMatch(str, "."));
                                 }
                                 else
                                 {
                                     // "${thread.id" <TAB>
-                                    matches.AppendString(std::move(MakeMatch (str, "}")));
+                                    matches.AppendString(MakeMatch (str, "}"));
                                     word_complete = true;
                                 }
                             }
                             else if (remainder.equals("."))
                             {
                                 // "${thread." <TAB>
                                 AddMatches(entry_def, str, llvm::StringRef(), matches);
                             }

lldb/trunk/source/Core/RegularExpression.cpp

 }
 
 bool
 RegularExpression::Match::GetMatchAtIndex (const char* s, uint32_t idx, std::string& match_str) const
 {
     llvm::StringRef match_str_ref;
     if (GetMatchAtIndex(s, idx, match_str_ref))
     {
-        match_str = std::move(match_str_ref.str());
+        match_str = match_str_ref.str();
         return true;
     }
     return false;
 }
 
 bool
 RegularExpression::Match::GetMatchAtIndex (const char* s, uint32_t idx, llvm::StringRef& match_str) const
 {
RegularExpression::GetErrorAsCString (char *err_str, size_t err_str_max_len) const
     return ::regerror (m_comp_err, &m_preg, err_str, err_str_max_len);
 }
 
 bool
 RegularExpression::operator < (const RegularExpression& rhs) const
 {
     return (m_re < rhs.m_re);
 }
-

lldb/trunk/source/Core/StreamAsynchronousIO.cpp

 }
 
 void
 StreamAsynchronousIO::Flush ()
 {
     if (!m_data.empty())
     {
         m_debugger.PrintAsync (m_data.data(), m_data.size(), m_for_stdout);
-        m_data = std::move(std::string());
+        m_data = std::string();
     }
 }
 
 size_t
 StreamAsynchronousIO::Write (const void *s, size_t length)
 {
     m_data.append ((const char *)s, length);
     return length;
 }

lldb/trunk/source/Expression/ClangExpressionParser.cpp

if (m_compiler->getCodeGenOpts().getDebugInfo() == CodeGenOptions::FullDebugInfo)
         std::string temp_source_path;
 
         int temp_fd = -1;
         llvm::SmallString<PATH_MAX> result_path;
         FileSpec tmpdir_file_spec;
         if (HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
         {
             tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
-            temp_source_path = std::move(tmpdir_file_spec.GetPath());
+            temp_source_path = tmpdir_file_spec.GetPath();
             llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
         }
         else
         {
             llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
         }
         
         if (temp_fd != -1)

lldb/trunk/source/Host/common/HostInfoBase.cpp

HostInfoBase::GetMaxThreadNameLength()
     return 0;
 }
 
 llvm::StringRef
 HostInfoBase::GetVendorString()
 {
     static std::once_flag g_once_flag;
     std::call_once(g_once_flag,  []() {
-        g_fields->m_vendor_string = std::move(HostInfo::GetArchitecture().GetTriple().getVendorName().str());
+        g_fields->m_vendor_string = HostInfo::GetArchitecture().GetTriple().getVendorName().str();
     });
     return g_fields->m_vendor_string;
 }
 
 llvm::StringRef
 HostInfoBase::GetOSString()
 {
     static std::once_flag g_once_flag;

lldb/trunk/source/Host/common/XML.cpp

ApplePropertyList::ExtractStringFromValueNode (const XMLNode &node, std::string &value)
     value.clear();
 #if defined( LIBXML2_DEFINED )
     if (node.IsValid())
     {
         llvm::StringRef element_name = node.GetName();
         if (element_name == "true" || element_name == "false")
         {
             // The text value _is_ the element name itself...
-            value = std::move(element_name.str());
+            value = element_name.str();
             return true;
         }
         else if (element_name == "dict" || element_name == "array")
             return false; // dictionaries and arrays have no text value, so we fail
         else
             return node.GetElementText(value);
     }
 #endif

 #if defined( LIBXML2_DEFINED )
     if (IsValid())
     {
         return CreatePlistValue(m_dict_node);
     }
 #endif
     return root_sp;
 }
-
-

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

thread_dict->ForEach([this,
                 array->ForEach([&exc_data](StructuredData::Object* object) -> bool {
                     exc_data.push_back(object->GetIntegerValue());
                     return true; // Keep iterating through all array items
                 });
             }
         }
         else if (key == g_key_name)
         {
-            thread_name = std::move(object->GetStringValue());
+            thread_name = object->GetStringValue();
         }
         else if (key == g_key_qaddr)
         {
             thread_dispatch_qaddr = object->GetIntegerValue(LLDB_INVALID_ADDRESS);
         }
         else if (key == g_key_queue_name)
         {
             queue_vars_valid = true;
-            queue_name = std::move(object->GetStringValue());
+            queue_name = object->GetStringValue();
         }
         else if (key == g_key_queue_kind)
         {
             std::string queue_kind_str = object->GetStringValue();
             if (queue_kind_str == "serial")
             {
                 queue_vars_valid = true;
                 queue_kind = eQueueKindSerial;
             }
             else if (queue_kind_str == "concurrent")
             {
                 queue_vars_valid = true;
                 queue_kind = eQueueKindConcurrent;
             }
         }
         else if (key == g_key_queue_serial)
         {
             queue_serial = object->GetIntegerValue(0);
             if (queue_serial != 0)
                 queue_vars_valid = true;
         }
         else if (key == g_key_reason)
         {
-            reason = std::move(object->GetStringValue());
+            reason = object->GetStringValue();
         }
         else if (key == g_key_description)
         {
-            description = std::move(object->GetStringValue());
+            description = object->GetStringValue();
         }
         else if (key == g_key_registers)
         {
             StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
 
             if (registers_dict)
             {
                 registers_dict->ForEach([&expedited_register_map](ConstString key, StructuredData::Object* object) -> bool {
                     const uint32_t reg = StringConvert::ToUInt32 (key.GetCString(), UINT32_MAX, 10);
                     if (reg != UINT32_MAX)
-                        expedited_register_map[reg] = std::move(object->GetStringValue());
+                        expedited_register_map[reg] = object->GetStringValue();
                     return true; // Keep iterating through all array items
                 });
             }
         }
         else if (key == g_key_memory)
         {
             StructuredData::Array *array = object->GetAsArray();
             if (array)
case 'S':
                     pair = value_ref.split('=');
                     if (!pair.first.empty() && !pair.second.empty())
                     {
                         std::string addr_str(pair.first.str());
                         const lldb::addr_t mem_cache_addr = StringConvert::ToUInt64(addr_str.c_str(), LLDB_INVALID_ADDRESS, 0);
                         if (mem_cache_addr != LLDB_INVALID_ADDRESS)
                         {
                             StringExtractor bytes;
-                            bytes.GetStringRef() = std::move(pair.second.str());
+                            bytes.GetStringRef() = pair.second.str();
                             const size_t byte_size = bytes.GetStringRef().size()/2;
                             DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
                             const size_t bytes_copied = bytes.GetHexBytes (data_buffer_sp->GetBytes(), byte_size, 0);
                             if (bytes_copied == byte_size)
                                 m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
                         }
                     }
                 }