Merge branch 'logger_fix_intel' into 'master'

Logger: fix intel compilation

See merge request swift/swiftsim!978

logger_header.c

@@ -93,8 +93,8 @@ void header_change_offset_direction(struct header *h,
   /* Skip file format and version numbers. */
   size_t offset = LOGGER_VERSION_SIZE + 2 * sizeof(int);
 
-  logger_loader_io_write_data(h->log->log.map + offset, sizeof(unsigned int),
-                              &new_value);
+  logger_loader_io_write_data((char *)h->log->log.map + offset,
+                              sizeof(unsigned int), &new_value);
 }
 
 /**
@@ -183,9 +183,9 @@ void header_read(struct header *h, struct logger_logfile *log) {
   }
 
   /* Check the logfile header's size. */
-  if (map != log->log.map + h->offset_first_record) {
+  if (map != (char *)log->log.map + h->offset_first_record) {
     header_print(h);
-    size_t offset = map - log->log.map;
+    size_t offset = (char *)map - (char *)log->log.map;
     error("Wrong header size (in header %zi, current %zi).",
           h->offset_first_record, offset);
   }

logger_index.c

@@ -64,18 +64,19 @@ void logger_index_read_header(struct logger_index *index,
   logger_index_map_file(index, filename, 0);
 
   /* Read times */
-  memcpy(&index->time, index->index.map + logger_index_time_offset,
+  memcpy(&index->time, (char *)index->index.map + logger_index_time_offset,
          logger_index_time_size);
   memcpy(&index->integer_time,
-         index->index.map + logger_index_integer_time_offset,
+         (char *)index->index.map + logger_index_integer_time_offset,
          logger_index_integer_time_size);
 
   /* Read the number of particles */
-  memcpy(index->nparts, index->index.map + logger_index_npart_offset,
+  memcpy(index->nparts, (char *)index->index.map + logger_index_npart_offset,
          logger_index_npart_size);
 
   /* Read if the file is sorted */
-  memcpy(&index->is_sorted, index->index.map + logger_index_is_sorted_offset,
+  memcpy(&index->is_sorted,
+         (char *)index->index.map + logger_index_is_sorted_offset,
          logger_index_is_sorted_size);
 
   /* Close the file */
@@ -94,7 +95,7 @@ void logger_index_write_sorted(struct logger_index *index) {
   const char is_sorted = 1;
 
   /* Write the value */
-  memcpy(index->index.map + logger_index_is_sorted_offset, &is_sorted,
+  memcpy((char *)index->index.map + logger_index_is_sorted_offset, &is_sorted,
          logger_index_is_sorted_size);
 }
 
@@ -113,7 +114,9 @@ struct index_data *logger_index_get_data(struct logger_index *index, int type) {
   }
   const size_t type_offset = count * sizeof(struct index_data);
 
-  return index->index.map + logger_index_data_offset + type_offset;
+  const char *ret =
+      (char *)index->index.map + logger_index_data_offset + type_offset;
+  return (struct index_data *)ret;
 }
 
 /**

logger_loader_io.h

@@ -61,14 +61,14 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_read_mask(
     *mask = 0;
     memcpy(mask, data, LOGGER_MASK_SIZE);
   }
-  data += LOGGER_MASK_SIZE;
+  data = (char *)data + LOGGER_MASK_SIZE;
 
   /* read offset */
   if (diff_offset) {
     *diff_offset = 0;
     memcpy(diff_offset, data, LOGGER_OFFSET_SIZE);
   }
-  data += LOGGER_OFFSET_SIZE;
+  data = (char *)data + LOGGER_OFFSET_SIZE;
 
   return data;
 }
@@ -85,7 +85,7 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_read_mask(
 __attribute__((always_inline)) INLINE static void *logger_loader_io_read_data(
     void *data, const size_t size, void *p) {
   memcpy(p, data, size);
-  return data + size;
+  return (char *)data + size;
 };
 
 /**
@@ -101,7 +101,7 @@ __attribute__((always_inline)) INLINE static void *logger_loader_io_write_data(
     void *data, const size_t size, const void *p) {
   memcpy(data, p, size);
 
-  return data + size;
+  return (char *)data + size;
 };
 
 #endif  // LOGGER_LOGGER_LOADER_IO_H

logger_particle.c

@@ -109,9 +109,9 @@ void *logger_particle_read_field(struct logger_particle *part, void *map,
     part->mass = 0;
     part->id = 0;
     memcpy(&part->mass, p, sizeof(float));
-    p += sizeof(float);
+    p = (char *)p + sizeof(float);
     memcpy(&part->id, p, sizeof(size_t));
-    p -= sizeof(float);
+    p = (char *)p - sizeof(float);
     free(p);
   }
 
@@ -149,7 +149,7 @@ size_t logger_particle_read(struct logger_particle *part,
   logger_particle_init(part);
 
   /* Read the record's mask. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &h_offset);
+  map = logger_loader_io_read_mask(h, (char *)map + offset, &mask, &h_offset);
 
   /* Check that the mask is meaningful */
   if (mask > (unsigned int)(1 << h->masks_count)) {
@@ -178,7 +178,7 @@ size_t logger_particle_read(struct logger_particle *part,
     part->time = -1;
 
   /* update the offset. */
-  offset = (size_t)(map - reader->log.log.map);
+  offset = (size_t)((char *)map - (char *)reader->log.log.map);
 
   /* Check if an interpolation is required. */
   if (reader_type == logger_reader_const) return offset;
@@ -192,7 +192,7 @@ size_t logger_particle_read(struct logger_particle *part,
   }
 
   /* No next particle. */
-  if (h_offset == 0) return (size_t)(map - reader->log.log.map);
+  if (h_offset == 0) return (size_t)((char *)map - (char *)reader->log.log.map);
 
   /* get absolute offset of next particle. */
   h_offset += offset - header_get_record_size_from_mask(h, mask) -

logger_reader.c

@@ -142,7 +142,8 @@ size_t reader_read_record(struct logger_reader *reader,
 
   /* Read mask to find out if timestamp or particle. */
   size_t mask = 0;
-  logger_loader_io_read_mask(&log->header, log->log.map + offset, &mask, NULL);
+  logger_loader_io_read_mask(&log->header, (char *)log->log.map + offset, &mask,
+                             NULL);
 
   /* Check if timestamp or not. */
   int ind = header_get_field_index(&log->header, "timestamp");
@@ -280,8 +281,8 @@ void logger_reader_read_all_particles_mapper(void *map_data, int num_elements,
       if (test == -1) {
         size_t mask = 0;
         logger_loader_io_read_mask(&reader->log.header,
-                                   reader->log.log.map + prev_offset, &mask,
-                                   &next_offset);
+                                   (char *)reader->log.log.map + prev_offset,
+                                   &mask, &next_offset);
         error(
             "Trying to get a particle without next record (mask: %zi, diff "
             "offset: %zi)",
@@ -412,8 +413,8 @@ void logger_reader_get_next_particle(struct logger_reader *reader,
   while (1) {
     /* Read the offset to the next particle */
     size_t mask = 0;
-    logger_loader_io_read_mask(&reader->log.header, map + prev_offset, &mask,
-                               &next_offset);
+    logger_loader_io_read_mask(&reader->log.header, (char *)map + prev_offset,
+                               &mask, &next_offset);
 
     /* Check if something special happened */
     if (mask & reader->log.header.masks[spec_flag_ind].mask) {

logger_time.c

@@ -92,7 +92,8 @@ size_t time_read(integertime_t *int_time, double *time,
   *time = 0;
 
   /* read record header. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &prev_offset);
+  map =
+      logger_loader_io_read_mask(h, (char *)map + offset, &mask, &prev_offset);
 
 #ifdef SWIFT_DEBUG_CHECKS
 
@@ -109,7 +110,7 @@ size_t time_read(integertime_t *int_time, double *time,
       logger_loader_io_read_data(map, sizeof(unsigned long long int), int_time);
   map = logger_loader_io_read_data(map, sizeof(double), time);
 
-  return map - h->log->log.map;
+  return (char *)map - (char *)h->log->log.map;
 }
 
 /**
@@ -131,7 +132,7 @@ size_t time_offset_first_record(const struct header *h) {
   if (i == -1) error("Time mask not present in the log file header.");
 
   size_t mask = 0;
-  logger_loader_io_read_mask(h, map + offset, &mask, NULL);
+  logger_loader_io_read_mask(h, (char *)map + offset, &mask, NULL);
 
   if (mask != h->masks[i].mask) error("Log file should begin by timestep.");
 

logger_tools.c

@@ -60,7 +60,8 @@ int _tools_get_next_record_forward(const struct header *h, void *map,
   size_t diff_offset = 0;
 
   /* Read the offset. */
-  map = logger_loader_io_read_mask(h, map + *offset, NULL, &diff_offset);
+  map =
+      logger_loader_io_read_mask(h, (char *)map + *offset, NULL, &diff_offset);
 
   if (diff_offset == 0) return -1;
 
@@ -91,7 +92,8 @@ int _tools_get_next_record_backward(const struct header *h, void *map,
   while (current_offset < file_size) {
     size_t mask = 0;
     size_t prev_offset;
-    logger_loader_io_read_mask(h, map + current_offset, &mask, &prev_offset);
+    logger_loader_io_read_mask(h, (char *)map + current_offset, &mask,
+                               &prev_offset);
 
     prev_offset = current_offset - prev_offset - record_header;
     if (*offset == prev_offset) {
@@ -123,16 +125,17 @@ size_t tools_reverse_offset(const struct header *h, void *file_map,
   void *map = file_map;
 
   /* read mask + offset. */
-  map = logger_loader_io_read_mask(h, map + offset, &mask, &prev_offset);
+  map =
+      logger_loader_io_read_mask(h, (char *)map + offset, &mask, &prev_offset);
 
   /* write offset of zero (in case it is the last record). */
   const size_t zero = 0;
-  map -= LOGGER_OFFSET_SIZE;
+  map = (char *)map - LOGGER_OFFSET_SIZE;
   map = logger_loader_io_write_data(map, LOGGER_OFFSET_SIZE, &zero);
 
   /* set offset after current record. */
-  map += header_get_record_size_from_mask(h, mask);
-  size_t after_current_record = (size_t)(map - file_map);
+  map = (char *)map + header_get_record_size_from_mask(h, mask);
+  size_t after_current_record = (size_t)((char *)map - (char *)file_map);
 
   /* first records do not have a previous partner. */
   if (prev_offset == cur_offset) return after_current_record;
@@ -142,12 +145,12 @@ size_t tools_reverse_offset(const struct header *h, void *file_map,
           cur_offset);
 
   /* modify previous offset. */
-  map = file_map + cur_offset - prev_offset + LOGGER_MASK_SIZE;
+  map = (char *)file_map + cur_offset - prev_offset + LOGGER_MASK_SIZE;
   map = logger_loader_io_write_data(map, LOGGER_OFFSET_SIZE, &prev_offset);
 
 #ifdef SWIFT_DEBUG_CHECKS
   size_t prev_mask = 0;
-  map -= LOGGER_MASK_SIZE + LOGGER_OFFSET_SIZE;
+  map = (char *)map - LOGGER_MASK_SIZE + LOGGER_OFFSET_SIZE;
   logger_loader_io_read_mask(h, map, &prev_mask, NULL);
 
   /* Check if we are not mixing timestamp and particles */
@@ -179,7 +182,7 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
 
   const struct header *h = &reader->log.header;
   void *file_init = reader->log.log.map;
-  void *map = file_init + offset;
+  void *map = (char *)file_init + offset;
 
   size_t mask;
   size_t pointed_offset;
@@ -200,15 +203,15 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
   }
 
   /* set offset after current record. */
-  map += header_get_record_size_from_mask(h, mask);
+  map = (char *)+header_get_record_size_from_mask(h, mask);
 
   if (pointed_offset == offset || pointed_offset == 0)
-    return (size_t)(map - file_init);
+    return (size_t)((char *)map - (char *)file_init);
 
   /* read mask of the pointed record. */
   size_t pointed_mask = 0;
-  logger_loader_io_read_mask(h, file_init + pointed_offset, &pointed_mask,
-                             NULL);
+  logger_loader_io_read_mask(h, (char *)file_init + pointed_offset,
+                             &pointed_mask, NULL);
 
   /* check if not mixing timestamp and particles. */
   if ((pointed_mask != h->timestamp_mask && mask == h->timestamp_mask) ||
@@ -216,7 +219,8 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
     error("Error in the offset (mask %lu at %lu != %lu at %lu).", mask, offset,
           pointed_mask, pointed_offset);
 
-  if (pointed_mask == h->timestamp_mask) return (size_t)(map - file_init);
+  if (pointed_mask == h->timestamp_mask)
+    return (size_t)((char *)map - (char *)file_init);
 
   struct logger_particle part;
   logger_particle_read(&part, reader, offset, 0, logger_reader_const);
@@ -229,5 +233,5 @@ size_t tools_check_record_consistency(const struct logger_reader *reader,
           pointed_offset);
   }
 
-  return (size_t)(map - file_init);
+  return (size_t)((char *)map - (char *)file_init);
 }