Being converting usage of off_t to other types

[zturner]

Summary

off_t is a type which is used for file offsets. Even more specifically, it is only used by a limited number of C APIs that deal with files. Any usage of off_t where the variable is not intended to be used with one of these APIs is a bug, by definition. This patch corrects some easy mis-uses of off_t, generally by converting them to lldb::offset_t, but sometimes by using other types such as size_t, when appropriate.

The use of off_t to represent these offsets has worked fine in practice on linux-y platforms, since we used _FILE_OFFSET_64 to guarantee that off_t was a uint64. On Windows, however, _FILE_OFFSET_64 is unrecognized, and off_t will always be 32-bit. So the usage of off_t on Windows actually leads to legitimate bugs.

[zturner]

Closed by commit rL212192 (authored by @zturner).

lldb/trunk/include/lldb/Core/Module.h

// ModuleList). If this is the case we need to know about it.
     /// @param[in] object_offset
     ///     The offset within an existing module used to extract a
     ///     module within a module (.a files and modules that contain
     ///     multiple architectures).
     //------------------------------------------------------------------
     Module (const FileSpec& file_spec,
             const ArchSpec& arch,
             const ConstString *object_name = NULL,
-            off_t object_offset = 0,
+            lldb::offset_t object_offset = 0,
             const TimeValue *object_mod_time_ptr = NULL);
 
     Module (const ModuleSpec &module_spec);
     
     static lldb::ModuleSP
     CreateJITModule (const lldb::ObjectFileJITDelegateSP &delegate_sp);
     
     //------------------------------------------------------------------

lldb/trunk/include/lldb/Core/ValueObject.h

GetValuesForExpressionPath(const char* expression,
                                ExpressionPathAftermath* final_task_on_target = NULL);
     
     virtual bool
     IsInScope ()
     {
         return true;
     }
 
-    virtual off_t
+    virtual lldb::offset_t
     GetByteOffset()
     {
         return 0;
     }
 
     virtual uint32_t
     GetBitfieldBitSize ()
     {

lldb/trunk/include/lldb/Core/ValueObjectChild.h

public:
     virtual ~ValueObjectChild();
 
     virtual uint64_t
     GetByteSize()
     {
         return m_byte_size;
     }
 
-    virtual off_t
+    virtual lldb::offset_t
     GetByteOffset()
     {
         return m_byte_offset;
     }
 
     virtual uint32_t
     GetBitfieldBitSize()
     {

lldb/trunk/include/lldb/Expression/ClangExpressionDeclMap.h

public:
     /// @return
     ///     True on success; false otherwise.
     //------------------------------------------------------------------
     bool 
     AddValueToStruct (const clang::NamedDecl *decl,
                       const ConstString &name,
                       llvm::Value *value,
                       size_t size,
-                      off_t alignment);
+                      lldb::offset_t alignment);
     
     //------------------------------------------------------------------
     /// [Used by IRForTarget] Finalize the struct, laying out the position 
     /// of each object in it.
     ///
     /// @return
     ///     True on success; false otherwise.
     //------------------------------------------------------------------
public:
     ///     The alignment of the struct, in bytes.
     ///
     /// @return
     ///     True if the information could be retrieved; false otherwise.
     //------------------------------------------------------------------
     bool 
     GetStructInfo (uint32_t &num_elements,
                    size_t &size,
-                   off_t &alignment);
+                   lldb::offset_t &alignment);
     
     //------------------------------------------------------------------
     /// [Used by IRForTarget] Get specific information about one field
     /// of the laid-out struct after DoStructLayout() has been called.
     ///
     /// @param[out] decl
     ///     The parsed Decl for the field, as generated by ClangASTSource
     ///     on ClangExpressionDeclMap's behalf.  In the case of the result
public:
     ///     The index of the field about which information is requested.
     ///
     /// @return
     ///     True if the information could be retrieved; false otherwise.
     //------------------------------------------------------------------
     bool 
     GetStructElement (const clang::NamedDecl *&decl,
                       llvm::Value *&value,
-                      off_t &offset,
+                      lldb::offset_t &offset,
                       ConstString &name,
                       uint32_t index);
     
     //------------------------------------------------------------------
     /// [Used by IRForTarget] Get information about a function given its
     /// Decl.
     ///
     /// @param[in] decl
struct StructVars {
             m_struct_alignment(0),
             m_struct_size(0),
             m_struct_laid_out(false),
             m_result_name(),
             m_object_pointer_type(NULL, NULL)
         {
         }
         
-        off_t                       m_struct_alignment;         ///< The alignment of the struct in bytes.
+        lldb::offset_t              m_struct_alignment;         ///< The alignment of the struct in bytes.
         size_t                      m_struct_size;              ///< The size of the struct in bytes.
         bool                        m_struct_laid_out;          ///< True if the struct has been laid out and the layout is valid (that is, no new fields have been added since).
         ConstString                 m_result_name;              ///< The name of the result variable ($1, for example)
         TypeFromUser                m_object_pointer_type;      ///< The type of the "this" variable, if one exists
     };
     
     std::unique_ptr<StructVars> m_struct_vars;
     

lldb/trunk/include/lldb/Expression/ClangExpressionVariable.h

public:
     struct JITVars {
         JITVars () :
             m_alignment (0),
             m_size (0),
             m_offset (0)
         {
         }
 
-        off_t   m_alignment;    ///< The required alignment of the variable, in bytes
-        size_t  m_size;         ///< The space required for the variable, in bytes
-        off_t   m_offset;       ///< The offset of the variable in the struct, in bytes
+        lldb::offset_t   m_alignment; ///< The required alignment of the variable, in bytes
+        size_t  m_size;               ///< The space required for the variable, in bytes
+        lldb::offset_t   m_offset;    ///< The offset of the variable in the struct, in bytes
     };
     
 private:
     typedef std::map <uint64_t, JITVars> JITVarMap;
     JITVarMap m_jit_vars;
     
 public:
     //----------------------------------------------------------------------

lldb/trunk/include/lldb/Symbol/DWARFCallFrameInfo.h

struct CIE
 
         CIE(dw_offset_t offset) : cie_offset(offset), version (-1), code_align (0),
                                   data_align (0), return_addr_reg_num (LLDB_INVALID_REGNUM), inst_offset (0),
                                   inst_length (0), ptr_encoding (0), initial_row() {}
     };
 
     typedef std::shared_ptr<CIE> CIESP;
 
-    typedef std::map<off_t, CIESP> cie_map_t;
+    typedef std::map<dw_offset_t, CIESP> cie_map_t;
 
     // Start address (file address), size, offset of FDE location
     // used for finding an FDE for a given File address; the start address field is
     // an offset into an individual Module.
     typedef RangeDataVector<lldb::addr_t, uint32_t, dw_offset_t> FDEEntryMap;
 
     bool
     IsEHFrame() const;

lldb/trunk/include/lldb/Symbol/ObjectFile.h

public:
     // valid ProcessSP, then subclasses can call this function to read
     // memory.
     static lldb::DataBufferSP
     ReadMemory (const lldb::ProcessSP &process_sp, 
                 lldb::addr_t addr, 
                 size_t byte_size);
 
     size_t
-    GetData (off_t offset, size_t length, DataExtractor &data) const;
+    GetData (lldb::offset_t offset, size_t length, DataExtractor &data) const;
     
     size_t
-    CopyData (off_t offset, size_t length, void *dst) const;
+    CopyData (lldb::offset_t offset, size_t length, void *dst) const;
     
     virtual size_t
     ReadSectionData (const Section *section, 
-                     off_t section_offset, 
+                     lldb::offset_t section_offset, 
                      void *dst, 
                      size_t dst_len) const;
     virtual size_t
     ReadSectionData (const Section *section, 
                      DataExtractor& section_data) const;
     
     size_t
     MemoryMapSectionData (const Section *section, 

lldb/trunk/include/lldb/Target/PathMappingList.h

public:
     
     void
     Insert (const ConstString &path, 
             const ConstString &replacement, 
             uint32_t insert_idx,
             bool notify);
 
     bool
-    Remove (off_t index, bool notify);
+    Remove (size_t index, bool notify);
 
     bool
     Remove (const ConstString &path, bool notify);
 
     bool
     Replace (const ConstString &path, 
              const ConstString &replacement, 
              bool notify);

lldb/trunk/source/Core/Module.cpp

Module::Module (const ModuleSpec &module_spec) :
     m_object_offset = matching_module_spec.GetObjectOffset();
     m_object_mod_time = matching_module_spec.GetObjectModificationTime();
     
 }
 
 Module::Module(const FileSpec& file_spec, 
                const ArchSpec& arch, 
                const ConstString *object_name, 
-               off_t object_offset,
+               lldb::offset_t object_offset,
                const TimeValue *object_mod_time_ptr) :
     m_mutex (Mutex::eMutexTypeRecursive),
     m_mod_time (file_spec.GetModificationTime()),
     m_arch (arch),
     m_uuid (),
     m_file (file_spec),
     m_platform_file(),
     m_remote_install_file (),

lldb/trunk/source/Expression/ClangExpressionDeclMap.cpp

 
 bool 
 ClangExpressionDeclMap::AddValueToStruct 
 (
     const NamedDecl *decl,
     const ConstString &name,
     llvm::Value *value,
     size_t size,
-    off_t alignment
+    lldb::offset_t alignment
 )
 {
     assert (m_struct_vars.get());
     assert (m_parser_vars.get());
 
     bool is_persistent_variable = false;
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
ClangExpressionDeclMap::DoStructLayout ()
     m_struct_vars->m_struct_laid_out = true;
     return true;
 }
 
 bool ClangExpressionDeclMap::GetStructInfo 
 (
     uint32_t &num_elements,
     size_t &size,
-    off_t &alignment
+    lldb::offset_t &alignment
 )
 {
     assert (m_struct_vars.get());
     
     if (!m_struct_vars->m_struct_laid_out)
         return false;
     
     num_elements = m_struct_members.GetSize();
     size = m_struct_vars->m_struct_size;
     alignment = m_struct_vars->m_struct_alignment;
     
     return true;
 }
 
 bool 
 ClangExpressionDeclMap::GetStructElement 
 (
     const NamedDecl *&decl,
     llvm::Value *&value,
-    off_t &offset,
+    lldb::offset_t &offset,
     ConstString &name,
     uint32_t index
 )
 {
     assert (m_struct_vars.get());
     
     if (!m_struct_vars->m_struct_laid_out)
         return false;

lldb/trunk/source/Expression/IRForTarget.cpp

else if (GlobalVariable *global_variable = dyn_cast<GlobalVariable>(llvm_value_ptr))
             value_type = PointerType::get(global_variable->getType(), 0);
         }
         else
         {
             value_type = global_variable->getType();
         }
         
         const uint64_t value_size = clang_type.GetByteSize();
-        off_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull;
+        lldb::offset_t value_alignment = (clang_type.GetTypeBitAlign() + 7ull) / 8ull;
         
         if (log)
         {
-            log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRId64 "]",
+            log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRIu64 "]",
                         name.c_str(), 
                         clang_type.GetQualType().getAsString().c_str(),
                         PrintType(value_type).c_str(),
                         value_size, 
                         value_alignment);
         }
         
         
IRForTarget::ReplaceVariables (Function &llvm_function)
     
     if (log)
         log->Printf("Element arrangement:");
     
     uint32_t num_elements;
     uint32_t element_index;
     
     size_t size;
-    off_t alignment;
+    lldb::offset_t alignment;
     
     if (!m_decl_map->GetStructInfo (num_elements, size, alignment))
         return false;
     
     Function::arg_iterator iter(llvm_function.getArgumentList().begin());
     
     if (iter == llvm_function.getArgumentList().end())
     {
if (!offset_type)
         
         return false;
     }
         
     for (element_index = 0; element_index < num_elements; ++element_index)
     {
         const clang::NamedDecl *decl = NULL;
         Value *value = NULL;
-        off_t offset;
+        lldb::offset_t offset;
         lldb_private::ConstString name;
         
         if (!m_decl_map->GetStructElement (decl, value, offset, name, element_index))
         {
             if (m_error_stream)
                 m_error_stream->Printf("Internal error [IRForTarget]: Structure information is incomplete");
             
             return false;
         }
             
         if (log)
-            log->Printf("  \"%s\" (\"%s\") placed at %" PRId64,
+            log->Printf("  \"%s\" (\"%s\") placed at %" PRIu64,
                         name.GetCString(),
                         decl->getNameAsString().c_str(),
                         offset);
     
         if (value)
         {
             if (log)
                 log->Printf("    Replacing [%s]", PrintValue(value).c_str());

lldb/trunk/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

public:
     virtual bool
     GetUUID (lldb_private::UUID* uuid);
 
     virtual uint32_t
     GetDependentModules (lldb_private::FileSpecList& files);
     
     virtual size_t
     ReadSectionData (const lldb_private::Section *section,
-                     off_t section_offset,
+                     lldb::offset_t section_offset,
                      void *dst,
                      size_t dst_len) const;
     virtual size_t
     ReadSectionData (const lldb_private::Section *section,
                      lldb_private::DataExtractor& section_data) const;
     
     //------------------------------------------------------------------
     // PluginInterface protocol

lldb/trunk/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

if (section_list)
         }
     }
     return num_loaded_sections > 0;
 }
 
     
 size_t
 ObjectFileJIT::ReadSectionData (const lldb_private::Section *section,
-                                off_t section_offset,
+                                lldb::offset_t section_offset,
                                 void *dst,
                                 size_t dst_len) const
 {
     lldb::offset_t file_size = section->GetFileSize();
-    if (section_offset < static_cast<off_t>(file_size))
+    if (section_offset < file_size)
     {
-        uint64_t src_len = file_size - section_offset;
+        size_t src_len = file_size - section_offset;
         if (src_len > dst_len)
             src_len = dst_len;
         const uint8_t *src = ((uint8_t *)(uintptr_t)section->GetFileOffset()) + section_offset;
         
         memcpy (dst, src, src_len);
         return src_len;
     }
     return 0;
 }
+
 size_t
 ObjectFileJIT::ReadSectionData (const lldb_private::Section *section,
                                 lldb_private::DataExtractor& section_data) const
 {
     if (section->GetFileSize())
     {
         const void *src = (void *)(uintptr_t)section->GetFileOffset();
     

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

if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
                         // terms of other registers, e.g. eax is a subset of rax) or not.  The slice registers 
                         // should NOT be in the g packet, but some implementations may incorrectly include them.
                         // 
                         // If the slice registers are included in the packet, we must step over the slice registers 
                         // when parsing the packet -- relying on the RegisterInfo byte_offset field would be incorrect.
                         // If the slice registers are not included, then using the byte_offset values into the
                         // data buffer is the best way to find individual register values.
 
-                        int size_including_slice_registers = 0;
-                        int size_not_including_slice_registers = 0;
-                        int size_by_highest_offset = 0;
+                        uint64_t size_including_slice_registers = 0;
+                        uint64_t size_not_including_slice_registers = 0;
+                        uint64_t size_by_highest_offset = 0;
 
                         for (uint32_t reg_idx=0; (reg_info = GetRegisterInfoAtIndex (reg_idx)) != NULL; ++reg_idx)
                         {
                             size_including_slice_registers += reg_info->byte_size;
                             if (reg_info->value_regs == NULL)
                                 size_not_including_slice_registers += reg_info->byte_size;
-                            if (static_cast<off_t>(reg_info->byte_offset) >= size_by_highest_offset)
+                            if (reg_info->byte_offset >= size_by_highest_offset)
                                 size_by_highest_offset = reg_info->byte_offset + reg_info->byte_size;
                         }
 
                         bool use_byte_offset_into_buffer;
-                        if (static_cast<size_t>(size_by_highest_offset) == restore_data.GetByteSize())
+                        if (size_by_highest_offset == restore_data.GetByteSize())
                         {
                             // The size of the packet agrees with the highest offset: + size in the register file
                             use_byte_offset_into_buffer = true;
                         }
-                        else if (static_cast<size_t>(size_not_including_slice_registers) == restore_data.GetByteSize())
+                        else if (size_not_including_slice_registers == restore_data.GetByteSize())
                         {
                             // The size of the packet is the same as concatenating all of the registers sequentially,
                             // skipping the slice registers
                             use_byte_offset_into_buffer = true;
                         }
-                        else if (static_cast<size_t>(size_including_slice_registers) == restore_data.GetByteSize())
+                        else if (size_including_slice_registers == restore_data.GetByteSize())
                         {
                             // The slice registers are present in the packet (when they shouldn't be).
                             // Don't try to use the RegisterInfo byte_offset into the restore_data, it will
                             // point to the wrong place.
                             use_byte_offset_into_buffer = false;
                         }
                         else {
                             // None of our expected sizes match the actual g packet data we're looking at.

lldb/trunk/source/Symbol/ObjectFile.cpp

if (process_sp)
                                                           error);
         if (bytes_read == byte_size)
             data_sp.reset (data_ap.release());
     }
     return data_sp;
 }
 
 size_t
-ObjectFile::GetData (off_t offset, size_t length, DataExtractor &data) const
+ObjectFile::GetData (lldb::offset_t offset, size_t length, DataExtractor &data) const
 {
     // The entire file has already been mmap'ed into m_data, so just copy from there
     // as the back mmap buffer will be shared with shared pointers.
     return data.SetData (m_data, offset, length);
 }
 
 size_t
-ObjectFile::CopyData (off_t offset, size_t length, void *dst) const
+ObjectFile::CopyData (lldb::offset_t offset, size_t length, void *dst) const
 {
     // The entire file has already been mmap'ed into m_data, so just copy from there
     // Note that the data remains in target byte order.
     return m_data.CopyData (offset, length, dst);
 }
 
 
 size_t
-ObjectFile::ReadSectionData (const Section *section, off_t section_offset, void *dst, size_t dst_len) const
+ObjectFile::ReadSectionData (const Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len) const
 {
     // If some other objectfile owns this data, pass this to them.
     if (section->GetObjectFile() != this)
         return section->GetObjectFile()->ReadSectionData (section, section_offset, dst, dst_len);
 
     if (IsInMemory())
     {
         ProcessSP process_sp (m_process_wp.lock());
         if (process_sp)
         {
             Error error;
             const addr_t base_load_addr = section->GetLoadBaseAddress (&process_sp->GetTarget());
             if (base_load_addr != LLDB_INVALID_ADDRESS)
                 return process_sp->ReadMemory (base_load_addr + section_offset, dst, dst_len, error);
         }
     }
     else
     {
-        const uint64_t section_file_size = section->GetFileSize();
-        if (section_offset < static_cast<off_t>(section_file_size))
+        const lldb::offset_t section_file_size = section->GetFileSize();
+        if (section_offset < section_file_size)
         {
-            const uint64_t section_bytes_left = section_file_size - section_offset;
-            uint64_t section_dst_len = dst_len;
+            const size_t section_bytes_left = section_file_size - section_offset;
+            size_t section_dst_len = dst_len;
             if (section_dst_len > section_bytes_left)
                 section_dst_len = section_bytes_left;
             return CopyData (section->GetFileOffset() + section_offset, section_dst_len, dst);
         }
         else
         {
             if (section->GetType() == eSectionTypeZeroFill)
             {

lldb/trunk/source/Target/PathMappingList.cpp

PathMappingList::Replace (const ConstString &path,
     ++m_mod_id;
     m_pairs[index] = pair(path, replacement);
     if (notify && m_callback)
         m_callback (*this, m_callback_baton);
     return true;
 }
 
 bool
-PathMappingList::Remove (off_t index, bool notify)
+PathMappingList::Remove (size_t index, bool notify)
 {
-    if (static_cast<size_t>(index) >= m_pairs.size())
+    if (index >= m_pairs.size())
         return false;
 
     ++m_mod_id;
     iterator iter = m_pairs.begin() + index;
     m_pairs.erase(iter);
     if (notify && m_callback)
         m_callback (*this, m_callback_baton);
     return true;