Fix gcov profiling on big-endian machines

[uweigand]

Summary

The compiler-rt library support for gcov is currently only working correctly on little-endian systems.

Two separate fixes are required to handle big-endian systems as well:

• 64-bit counter values are stored in a mixed-endian format in the gcov files: a 32-bit low-part followed by a 32-bit high part. Note that this is already implemented correctly on the LLVM side, see GCOVBuffer::readInt64.
• The tag values (e.g. arcs tag, object summary tag, ...) are aways written as the same sequence of bytes independent of byte order. But when *reading* them back in, the code reads them as 32-bit values in host byte order. For the comparisons to work correctly, this should instead always read them as little-endian values.

[marco-c]

I've just relanded https://reviews.llvm.org/D48538 in r336678, once the issues which made the tests fail are fixed we should remove the XFAILs. I've filed https://bugs.llvm.org/show_bug.cgi?id=38121 to track it.

[uweigand]

This caused a build bot failure here:
http://lab.llvm.org:8011/builders/clang-x86_64-linux-abi-test/builds/28963

Apparently this file may not use C99 syntax "for (int i = ...". I've checked in the obvious fix as r336706.

[MaskRay]

This change is wrong. I can understand the intention: llvm-cov does not process big-endian .gcno/.gcda correctly.
gcov reads/writes integral values in the executable's endianness. On a big-endian machine, the values are stored in big-endian. This change is not going to work with gcov shipped by GCC.

I am fixing some gcov problems. We should just UNSUPPORTED: host-byteorder-big-endian until llvm-cov and compiler-rt/lib/profile are actually fixed for big endian.

[uweigand]

Hmm, I still think the read/write_64bit_value change is correct, GCC does read/write 64-bit counter values as lo/hi pairs even on big-endian systems.

However, it does appear that you're right about the read_le_32bit_value change; I've added this for the tags checks, but this looks wrong. GCC does read/write those in native endian byte order. I guess this part of the change should be reverted, and instead the code that writes tags should be changed to use write_32bit_value instead of write_bytes.

compiler-rt/trunk/lib/profile/GCDAProfiling.c

static void write_bytes(const char *s, size_t len) {
   cur_pos += len;
 }
 
 static void write_32bit_value(uint32_t i) {
   write_bytes((char*)&i, 4);
 }
 
 static void write_64bit_value(uint64_t i) {
-  write_bytes((char*)&i, 8);
+  // GCOV uses a lo-/hi-word format even on big-endian systems.
+  // See also GCOVBuffer::readInt64 in LLVM.
+  uint32_t lo = (uint32_t) i;
+  uint32_t hi = (uint32_t) (i >> 32);
+  write_32bit_value(lo);
+  write_32bit_value(hi);
 }
 
 static uint32_t length_of_string(const char *s) {
   return (strlen(s) / 4) + 1;
 }
 
 static void write_string(const char *s) {
   uint32_t len = length_of_string(s);
   write_32bit_value(len);
   write_bytes(s, strlen(s));
   write_bytes("\0\0\0\0", 4 - (strlen(s) % 4));
 }
 
 static uint32_t read_32bit_value() {
   uint32_t val;
 
   if (new_file)
     return (uint32_t)-1;
 
   val = *(uint32_t*)&write_buffer[cur_pos];
   cur_pos += 4;
   return val;
 }
 
-static uint64_t read_64bit_value() {
-  uint64_t val;
+static uint32_t read_le_32bit_value() {
+  uint32_t val = 0;
 
   if (new_file)
-    return (uint64_t)-1;
+    return (uint32_t)-1;
 
-  val = *(uint64_t*)&write_buffer[cur_pos];
-  cur_pos += 8;
+  for (int i = 0; i < 4; i++)
+    val |= write_buffer[cur_pos++] << (8*i);
   return val;
 }
 
+static uint64_t read_64bit_value() {
+  // GCOV uses a lo-/hi-word format even on big-endian systems.
+  // See also GCOVBuffer::readInt64 in LLVM.
+  uint32_t lo = read_32bit_value();
+  uint32_t hi = read_32bit_value();
+  return ((uint64_t)hi << 32) | ((uint64_t)lo);
+}
+
 static char *mangle_filename(const char *orig_filename) {
   char *new_filename;
   size_t prefix_len;
   int prefix_strip;
   const char *prefix = lprofGetPathPrefix(&prefix_strip, &prefix_len);
 
   if (prefix == NULL)
     return strdup(orig_filename);

 void llvm_gcda_emit_arcs(uint32_t num_counters, uint64_t *counters) {
   uint32_t i;
   uint64_t *old_ctrs = NULL;
   uint32_t val = 0;
   uint64_t save_cur_pos = cur_pos;
 
   if (!output_file) return;
 
-  val = read_32bit_value();
+  val = read_le_32bit_value();
 
   if (val != (uint32_t)-1) {
     /* There are counters present in the file. Merge them. */
     if (val != 0x01a10000) {
       fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: "
                       "corrupt arc tag (0x%08x)\n",
               filename, val);
       return;
void llvm_gcda_summary_info() {
   uint32_t i;
   uint32_t runs = 1;
   static uint32_t run_counted = 0; // We only want to increase the run count once.
   uint32_t val = 0;
   uint64_t save_cur_pos = cur_pos;
 
   if (!output_file) return;
 
-  val = read_32bit_value();
+  val = read_le_32bit_value();
 
   if (val != (uint32_t)-1) {
     /* There are counters present in the file. Merge them. */
     if (val != 0xa1000000) {
       fprintf(stderr, "profiling: %s: cannot merge previous run count: "
                       "corrupt object tag (0x%08x)\n",
               filename, val);
       return;