std::filesystem:file_size send me an incoherent value

Question

In order to read a file in my code, I use std::filesystem::file_size (https://en.cppreference.com/w/cpp/filesystem/file_size) to get his size. I use this code :

template <typename TYPE>
inline void read_binary_file(const fs::path filename, std::vector<TYPE>& result) 
{ 
  std::ifstream file(filename, std::ios::in | std::ios::binary); 
  __ERR_READFILE01__ // file cannot be open 
  SPDLOG_DEBUG("Reading {}", filename.u8string()); 
 
  size_t filesize; 
  try
  { 
    filesize = fs::file_size(filename); 
  } 
  catch(fs::filesystem_error& e) 
  { 
    std::cout << e.what() << '\n'; abort(); 
  } 
  assert(filesize%sizeof(TYPE) == 0); 
  SPDLOG_DEBUG("size of file {}", filesize); 
  SPDLOG_DEBUG("size of {}", static_cast<std::uintmax_t>(-1)); 
  SPDLOG_DEBUG("size of type {}", sizeof(TYPE)); 
  SPDLOG_DEBUG("size of the reading vector {}", filesize/sizeof(TYPE));  
  result.resize(filesize/sizeof(TYPE)); 
  file.read(reinterpret_cast<char*>(result.data()), filesize); 
  file.close(); 
}

This works for most of the files I need to read, but for a file ( ~3 gigas), I have a strange issue :

[07/12/2020 11:52:42][debug] size of file 18446744072617361848 
[07/12/2020 11:52:42][debug] size of 18446744073709551615 
[07/12/2020 11:52:42][debug] size of type 4 
[07/12/2020 11:52:42][debug] size of the reading vector 4611686018154340462

In the documentation, I can read The non-throwing overload returns static_cast<std::uintmax_t>(-1) on errors. . But the value 18446744072617361848 is different from static_cast<std::uintmax_t>(-1), so I am lost ....

My compiler is mingw32 :

mingw32-make.exe --version 
GNU Make 4.3 Built for Windows32 Copyright (C) 1988-2020 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.

I don't have the issue on linux (gcc).

Answer 1

There is a bug that will be corrected in recent versions of MinGW. cf:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95749

But event that, should replace

  size_t filesize; 

by

std::uintmax_t filesize; 

according the function's signature :

std::uintmax_t file_size( const std::filesystem::path& p );

Answer 2

fs::file_size(filename); returns a std::uintmax_t. Which is probably a 64bit integer. You assign that to a size_t which maybe (and probably is given your error) a 32 bit integer.

Just use a uintmax_t:

uintmax_t filesize;

Answer 3

This may be a bug of MinGW32. The size you just got is a signed extension of 3202777528, you can check this value by yourself:

uint32_t real_file_size = 3202777528u; // roughly 3GB as you said
auto value_you_see = (uint64_t)(int32_t)real_file_size;

My guess is that MinGW32 uses ssize_t internally, which is an alias to int32_t in a 32-bits environment. Maybe you should use MinGW64 instead.

Answer 4

Like says by Florent, it seems to be a bug. gcc 10.2 on windows use _wstat which is a 32 bits function. The correction will coming soon, in the version 10.3 of gcc on windows.