Fix s390 build

The goal of this patch is to make isa-l testsuite pass on s390 with
minimal changes to the library. The one and only reason isa-l does not
work on s390 at the moment is that s390 is big-endian, and isa-l
assumes little-endian at a lot of places.

There are two flavors of this: loading/storing integers from/to
memory, and overlapping structs. Loads/stores are already helpfully
wrapped by unaligned.h header, so replace the functions there with
endianness-aware variants. Solve struct member overlap by reversing
their order on big-endian.

Also, fix a couple of usages of uninitialized memory in the testsuite
(found with MemorySanitizer).

Fixes s390x part of #188.

Change-Id: Iaf14a113bd266900192cc8b44212f8a47a8c7753
Signed-off-by: Ilya Leoshkevich <[email protected]>

Author: iii-i

erasure_code/ec_base.c

@@ -171,7 +171,7 @@ void gf_vect_mul_init(unsigned char c, unsigned char *tbl)
 	unsigned char c4 = (c2 << 1) ^ ((c2 & 0x80) ? 0x1d : 0);	//Mult by GF{2}
 	unsigned char c8 = (c4 << 1) ^ ((c4 & 0x80) ? 0x1d : 0);	//Mult by GF{2}
 
-#if __WORDSIZE == 64 || _WIN64 || __x86_64__
+#if (__WORDSIZE == 64 || _WIN64 || __x86_64__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
 	unsigned long long v1, v2, v4, v8, *t;
 	unsigned long long v10, v20, v40, v80;
 	unsigned char c17, c18, c20, c24;

igzip/bitbuf2.h

@@ -36,7 +36,6 @@
 #define inline __inline
 #endif
 
-
 /* MAX_BITBUF_BIT WRITE is the maximum number of bits than can be safely written
  * by consecutive calls of write_bits. Note this assumes the bitbuf is in a
  * state that is possible at the exit of write_bits */
@@ -60,28 +59,28 @@ static inline int is_full(struct BitBuf2 *me)
 	return (me->m_out_buf > me->m_out_end);
 }
 
-static inline uint8_t * buffer_ptr(struct BitBuf2 *me)
+static inline uint8_t *buffer_ptr(struct BitBuf2 *me)
 {
 	return me->m_out_buf;
 }
 
 static inline uint32_t buffer_used(struct BitBuf2 *me)
 {
-	return (uint32_t)(me->m_out_buf - me->m_out_start);
+	return (uint32_t) (me->m_out_buf - me->m_out_start);
 }
 
 static inline uint32_t buffer_bits_used(struct BitBuf2 *me)
 {
-	return (8 * (uint32_t)(me->m_out_buf - me->m_out_start) + me->m_bit_count);
+	return (8 * (uint32_t) (me->m_out_buf - me->m_out_start) + me->m_bit_count);
 }
 
 static inline void flush_bits(struct BitBuf2 *me)
 {
 	uint32_t bits;
-	store_u64(me->m_out_buf, me->m_bits);
+	store_le_u64(me->m_out_buf, me->m_bits);
 	bits = me->m_bit_count & ~7;
 	me->m_bit_count -= bits;
-	me->m_out_buf += bits/8;
+	me->m_out_buf += bits / 8;
 	me->m_bits >>= bits;
 
 }
@@ -91,7 +90,7 @@ static inline void flush(struct BitBuf2 *me)
 {
 	uint32_t bytes;
 	if (me->m_bit_count) {
-		store_u64(me->m_out_buf, me->m_bits);
+		store_le_u64(me->m_out_buf, me->m_bits);
 		bytes = (me->m_bit_count + 7) / 8;
 		me->m_out_buf += bytes;
 	}
@@ -114,14 +113,14 @@ static inline void write_bits_unsafe(struct BitBuf2 *me, uint64_t code, uint32_t
 }
 
 static inline void write_bits(struct BitBuf2 *me, uint64_t code, uint32_t count)
-{	/* Assumes there is space to fit code into m_bits. */
+{				/* Assumes there is space to fit code into m_bits. */
 	me->m_bits |= code << me->m_bit_count;
 	me->m_bit_count += count;
 	flush_bits(me);
 }
 
 static inline void write_bits_flush(struct BitBuf2 *me, uint64_t code, uint32_t count)
-{	/* Assumes there is space to fit code into m_bits. */
+{				/* Assumes there is space to fit code into m_bits. */
 	me->m_bits |= code << me->m_bit_count;
 	me->m_bit_count += count;
 	flush(me);

igzip/encode_df.h

@@ -20,11 +20,17 @@
 #define ICF_CODE_LEN 32
 
 struct deflate_icf {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 	uint32_t lit_len:LIT_LEN_BIT_COUNT;
 	uint32_t lit_dist:DIST_LIT_BIT_COUNT;
 	uint32_t dist_extra:ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET;
+#else
+	uint32_t dist_extra:ICF_CODE_LEN - DIST_LIT_BIT_COUNT - ICF_DIST_OFFSET;
+	uint32_t lit_dist:DIST_LIT_BIT_COUNT;
+	uint32_t lit_len:LIT_LEN_BIT_COUNT;
+#endif
 };
 
 struct deflate_icf *encode_deflate_icf(struct deflate_icf *next_in, struct deflate_icf *end_in,
-			               struct BitBuf2 *bb, struct hufftables_icf * hufftables);
+				       struct BitBuf2 *bb, struct hufftables_icf *hufftables);
 #endif

igzip/generate_custom_hufftables.c

@@ -291,13 +291,13 @@ void isal_update_histogram_dict(uint8_t * start_stream, int dict_length, int len
 	memset(last_seen, 0, sizeof(histogram->hash_table));	/* Initialize last_seen to be 0. */
 
 	for (current = start_stream; current < end_dict - 4; current++) {
-		literal = load_u32(current);
+		literal = load_le_u32(current);
 		hash = compute_hash(literal) & LVL0_HASH_MASK;
 		last_seen[hash] = (current - start_stream) & 0xFFFF;
 	}
 
 	for (current = start_stream + dict_length; current < end_stream - 3; current++) {
-		literal = load_u32(current);
+		literal = load_le_u32(current);
 		hash = compute_hash(literal) & LVL0_HASH_MASK;
 		seen = last_seen[hash];
 		last_seen[hash] = (current - start_stream) & 0xFFFF;
@@ -317,7 +317,7 @@ void isal_update_histogram_dict(uint8_t * start_stream, int dict_length, int len
 					end = end_stream - 3;
 				next_hash++;
 				for (; next_hash < end; next_hash++) {
-					literal = load_u32(next_hash);
+					literal = load_le_u32(next_hash);
 					hash = compute_hash(literal) & LVL0_HASH_MASK;
 					last_seen[hash] = (next_hash - start_stream) & 0xFFFF;
 				}

igzip/huff_codes.c

@@ -680,7 +680,7 @@ void isal_update_histogram_base(uint8_t * start_stream, int length,
 	end_stream = start_stream + length;
 	memset(last_seen, 0, sizeof(histogram->hash_table));	/* Initialize last_seen to be 0. */
 	for (current = start_stream; current < end_stream - 3; current++) {
-		literal = load_u32(current);
+		literal = load_le_u32(current);
 		hash = compute_hash(literal) & LVL0_HASH_MASK;
 		seen = last_seen[hash];
 		last_seen[hash] = (current - start_stream) & 0xFFFF;
@@ -700,7 +700,7 @@ void isal_update_histogram_base(uint8_t * start_stream, int length,
 					end = end_stream - 3;
 				next_hash++;
 				for (; next_hash < end; next_hash++) {
-					literal = load_u32(next_hash);
+					literal = load_le_u32(next_hash);
 					hash = compute_hash(literal) & LVL0_HASH_MASK;
 					last_seen[hash] = (next_hash - start_stream) & 0xFFFF;
 				}

igzip/huff_codes.h

@@ -104,24 +104,40 @@
  */
 struct huff_code {
 	union {
-                struct {
-                        uint32_t code_and_extra:24;
-                        uint32_t length2:8;
-                };
+		struct {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+			uint32_t code_and_extra:24;
+			uint32_t length2:8;
+#else
+			uint32_t length2:8;
+			uint32_t code_and_extra:24;
+#endif
+		};
 
 		struct {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 			uint16_t code;
 			uint8_t extra_bit_count;
 			uint8_t length;
+#else
+			uint8_t length;
+			uint8_t extra_bit_count;
+			uint16_t code;
+#endif
 		};
 
 		uint32_t code_and_length;
 	};
 };
 
 struct tree_node {
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 	uint32_t child;
 	uint32_t depth;
+#else
+	uint32_t depth;
+	uint32_t child;
+#endif
 };
 
 struct heap_tree {
@@ -164,7 +180,7 @@ struct hufftables_icf {
  * with the set hufftable
  */
 uint64_t
-create_hufftables_icf(struct BitBuf2 *bb, struct hufftables_icf * hufftables,
-                  struct isal_mod_hist *hist, uint32_t end_of_block);
+create_hufftables_icf(struct BitBuf2 *bb, struct hufftables_icf *hufftables,
+		      struct isal_mod_hist *hist, uint32_t end_of_block);
 
 #endif