WIP - Totally remove host endianness dependence

- Adds endian aware functions
- Removes references to host endian
- Uses binary detected endianness else tries LE and restricts by RAsmPlugin
- Fixes gdb debugger endianness when debugging BE qemu gdbserver

Signed-off-by: Damien Zammit <[email protected]>

Author: zamaudio

AUTHORS.md

@@ -74,6 +74,7 @@ This release comes with contributions from the following people:
  - ampotos
  - capi_x
  - cosarara
+ - damo22
  - dso (Adam Pridgen)
  - dunhame
  - dx

binr/rasm2/rasm2.c

@@ -332,6 +332,7 @@ int main (int argc, char *argv[]) {
 	const char *env_bits = r_sys_getenv ("RASM2_BITS");
 	unsigned char buf[R_ASM_BUFSIZE];
 	char *arch = NULL, *file = NULL, *filters = NULL, *kernel = NULL, *cpu = NULL, *tmp;
+	bool isbig = false;
 	ut64 offset = 0;
 	int fd = -1, dis = 0, ascii = 0, bin = 0, ret = 0, bits = 32, c, whatsop = 0;
 	ut64 len = 0, idx = 0, skip = 0;
@@ -377,8 +378,8 @@ int main (int argc, char *argv[]) {
 		r_asm_set_bits (a, sysbits);
 		r_anal_set_bits (anal, sysbits);
 	}
-	r_asm_set_big_endian (a, false);
-	r_anal_set_big_endian (anal, false);
+	isbig = r_asm_set_big_endian (a, false);
+	r_anal_set_big_endian (anal, isbig);
 
 	while ((c = getopt (argc, argv, "Ai:k:DCc:eEva:b:s:do:Bl:hjLf:F:wO:")) != -1) {
 		switch (c) {
@@ -407,7 +408,8 @@ int main (int argc, char *argv[]) {
 			dis = 2;
 			break;
 		case 'e':
-			r_asm_set_big_endian (a, !a->big_endian);
+			isbig = r_asm_set_big_endian (a, true);
+			r_anal_set_big_endian (anal, isbig);
 			break;
 		case 'E':
 			dis = 3;

binr/rax2/rax2.c

@@ -15,16 +15,14 @@ static int rax (char *str, int len, int last);
 
 static int format_output (char mode, const char *s) {
 	ut64 n = r_num_math (num, s);
-	const char *str = (char*)&n;
 	char strbits[65];
 
 	if (force_mode)
 		mode = force_mode;
 
 	if (flags & 2) {
-		/* swap endian */
-		ut32 n2 = (n >> 32) ? 8 : 4;
-		r_mem_copyendian ((ut8*)str, (ut8*)str, n2, 0);
+		ut64 n2 = n;
+		r_mem_swapendian ((ut8*)&n, (ut8*)&n2, (n >> 32) ? 8 : 4);
 	}
 	switch (mode) {
 	case 'I': printf ("%"PFMT64d"\n", n); break;
@@ -307,7 +305,6 @@ static int rax (char *str, int len, int last) {
 	} else if (flags & 2048) { // -t
 		ut32 n = r_num_math (num, str);
 		RPrint *p = r_print_new ();
-		r_mem_copyendian ((ut8*) &n, (ut8*) &n, 4, !(flags & 2));
 		r_print_date_unix (p, (const ut8*)&n, sizeof (ut32));
 		r_print_free (p);
 		return true;

doc/endian

@@ -0,0 +1,68 @@
+Endian issues
+=============
+
+As hackers, we need to be aware of endianness.
+
+Endianness can become a problem when you try to process buffers or streams
+of bytes and store intermediate values as integers with width larger than
+a single byte.
+
+It can seem very easy to write the following code:
+
+	ut8 opcode[4] = {0x10, 0x20, 0x30, 0x40};
+	ut32 value = *(ut32*)opcode;
+	
+	... and then continue to use "value" in the code to represent the opcode.
+
+This needs to be avoided!
+
+Why? What is actually happening?
+
+When you cast the opcode stream to a unsigned int, the compiler uses the endianness
+of the host to interpret the bytes and stores it in host endianness.  This leads to
+very unportable code, because if you compile on a different endian machine, the
+value stored in "value" might be 0x40302010 instead of 0x10203040.
+
+In the past, radare devs were not as strict about this issue, and as a result,
+needed to swap the endian of values regularly in the code.
+
+Solution
+========
+
+Use bitshifts and OR instructions to interpret bytes in a known endian.
+Instead of casting streams of bytes to larger width integers, do the following:
+
+	ut8 opcode[4] = {0x10, 0x20, 0x30, 0x40};
+	ut32 value = opcode[0] | opcode[1] << 8 | opcode[2] << 16 | opcode[3] << 24;
+
+	or if you prefer the other endian:
+
+	ut32 value = opcode[3] | opcode[2] << 8 | opcode[1] << 16 | opcode[0] << 24;
+
+This is much better because you actually know which endian your bytes are stored in
+within the integer value, REGARDLESS of the host endian of the machine.
+
+
+Endian helper functions
+=======================
+
+Radare2 now uses helper functions to interpret all byte streams in a known endian.
+
+Please use these at all times, eg:
+
+	val32 = r_read_be32(buffer)		// reads 4 bytes from a stream in BE
+	val32 = r_read_le32(buffer)		// reads 4 bytes from a stream in LE
+	val32 = r_read_ble32(buffer, isbig)	// reads 4 bytes from a stream:
+						//   if isbig is true, reads in BE
+						//   otherwise reads in LE
+
+There are a number of helper functions for 64, 32, 16, and 8 bit reads and writes.
+
+(Note that 8 bit reads are equivalent to casting a single byte of the buffer
+to a ut8 value, ie endian is irrelevant).
+
+Happy hacking!
+
+- damo22
+
+

doc/fortunes.fun

@@ -187,3 +187,6 @@ Run a command with unspecified long sequence of 'a', pancake will be summoned an
 In r2land usability is treated as a bug
 radare2 is WYSIWYF - what you see is what you fix
 Your endian swaps
+*(ut64*)buffer ought to be illegal
+MY ENDIAN IS HUUUGE
+enlarge your endian

doc/fortunes.nsfw

@@ -27,3 +27,4 @@ less stupid than putting CO2 in your ass.
 Puritans, ruining everything since the 16th century.
 Better fuck a watermelon.
 Can you deal with an ascii penis?
+two girls one endian

libr/anal/anal.c

@@ -113,7 +113,6 @@ R_API RAnal *r_anal_new() {
 	anal->refs = r_anal_ref_list_new ();
 	anal->types = r_anal_type_list_new ();
 	r_anal_set_bits (anal, 32);
-	r_anal_set_big_endian (anal, false);
 	anal->plugins = r_list_newf ((RListFree) r_anal_plugin_free);
 	if (anal->plugins) {
 		for (i=0; anal_static_plugins[i]; i++) {

libr/anal/data.c

@@ -31,8 +31,8 @@ static int is_string(const ut8 *buf, int size, int *len) {
 	return 1;
 }
 
-static int is_number(const ut8 *buf, int endian, int size) {
-	ut64 n = r_mem_get_num (buf, size, endian);
+static int is_number(const ut8 *buf, int size) {
+	ut64 n = r_mem_get_num (buf, size);
 	return (n < UT32_MAX)? (int)n: 0;
 }
 
@@ -48,12 +48,13 @@ static int is_invalid(const ut8 *buf, int size) {
 }
 
 #define USE_IS_VALID_OFFSET 1
-static ut64 is_pointer(RIOBind *iob, const ut8 *buf, int endian, int size) {
+static ut64 is_pointer(RAnal *anal, const ut8 *buf, int size) {
 	ut64 n;
 	ut8 buf2[32];
+	RIOBind *iob = &anal->iob;
 	if (size > sizeof (buf2))
 		size = sizeof (buf2);
-	n = r_mem_get_num (buf, size, endian);
+	n = r_mem_get_num (buf, size);
 	if (!n) return 1; // null pointer
 #if USE_IS_VALID_OFFSET
 	int r = iob->is_valid_offset (iob->io, n, 0);
@@ -227,7 +228,6 @@ R_API RAnalData *r_anal_data(RAnal *anal, ut64 addr, const ut8 *buf, int size) {
 	ut64 dst = 0;
 	int n, nsize = 0;
 	int bits = anal->bits;
-	int endi = !anal->big_endian;
 	int word = R_MIN (8, bits / 8);
 
 	if (size < 4)
@@ -266,7 +266,7 @@ R_API RAnalData *r_anal_data(RAnal *anal, ut64 addr, const ut8 *buf, int size) {
 		return r_anal_data_new (addr, R_ANAL_DATA_TYPE_HEADER, -1,
 					buf, word);
 	if (size >= word) {
-		dst = is_pointer (&anal->iob, buf, endi, word);
+		dst = is_pointer (anal, buf, word);
 		if (dst) return r_anal_data_new (addr,
 						R_ANAL_DATA_TYPE_POINTER, dst, buf, word);
 	}
@@ -277,7 +277,7 @@ R_API RAnalData *r_anal_data(RAnal *anal, ut64 addr, const ut8 *buf, int size) {
 					nsize, R_ANAL_DATA_TYPE_WIDE_STRING);
 	}
 	if (size >= word) {
-		n = is_number (buf, endi, word);
+		n = is_number (buf, word);
 		if (n) return r_anal_data_new (addr, R_ANAL_DATA_TYPE_NUMBER,
 					n, buf, word);
 	}

libr/anal/esil.c

@@ -1379,12 +1379,8 @@ static int esil_deceq(RAnalEsil *esil) {
 static int esil_poke_n(RAnalEsil *esil, int bits) {
 	ut64 bitmask = genmask (bits - 1);
 	ut64 num, addr;
-	union {
-		ut8 byte;
-		ut16 word;
-		ut32 dword;
-		ut64 qword;
-	} n, n2;
+	ut8 b[sizeof(ut64)];
+	ut64 n;
 	char *dst = r_anal_esil_pop (esil);
 	char *src = r_anal_esil_pop (esil);
 	int bytes = bits / 8, ret = 0;
@@ -1398,16 +1394,15 @@ static int esil_poke_n(RAnalEsil *esil, int bits) {
 		if (dst && r_anal_esil_get_parm (esil, dst, &addr)) {
 			int type = r_anal_esil_get_parm_type (esil, src);
 			if (type != R_ANAL_ESIL_PARM_INTERNAL) {
-				n.qword = n2.qword = 0;
-				r_anal_esil_mem_read (esil, addr, (ut8 *)&n, bytes);
-				r_mem_copyendian ((ut8 *)&n2, (ut8 *)&n, bytes, !esil->anal->big_endian);
-				esil->old = n2.qword;
+				r_anal_esil_mem_read (esil, addr, b, bytes);
+				n = r_read_ble64 (b, esil->anal->big_endian);
+				esil->old = n;
 				esil->cur = (num & bitmask);
 				esil->lastsz = bits;
 				num = num & bitmask;
 			}
-			r_mem_copyendian ((ut8 *)&n, (ut8 *)&num, bytes, !esil->anal->big_endian);
-			ret = r_anal_esil_mem_write (esil, addr, (const ut8 *)&n, bytes);
+			r_write_ble64 (b, num, esil->anal->big_endian);
+			ret = r_anal_esil_mem_write (esil, addr, b, bytes);
 		}
 	}
 	free (src);
@@ -1433,30 +1428,31 @@ static int esil_poke(RAnalEsil *esil) {
 
 static int esil_poke_some(RAnalEsil *esil) {
 	int i, ret = 0;
+	int regsize;
 	ut64 ptr, regs;
 	char *count, *dst = r_anal_esil_pop (esil);
-	if (dst) {
+	if (dst && r_anal_esil_get_parm_size (esil, dst, NULL, &regsize)) {
+		ut8 bytes = regsize / 8;
 		// reg
 		isregornum (esil, dst, &ptr);
 		count = r_anal_esil_pop (esil);
 		if (count) {
 			isregornum (esil, count, &regs);
 			if (regs > 0) {
+				ut8 b[bytes];
 				ut64 num64;
-				ut32 num32;
 				for (i = 0; i < regs; i++) {
 					char *foo = r_anal_esil_pop (esil);
 					isregornum (esil, foo, &num64);
 					/* TODO: implement peek here */
 					// read from $dst
-					num32 = num64;
-					ret = r_anal_esil_mem_write (esil, ptr,
-								(const ut8 *)&num32, sizeof (num32));
-					if (ret != sizeof (num32)) {
+					r_write_ble64 (b, num64, esil->anal->big_endian);
+					ret = r_anal_esil_mem_write (esil, ptr, b, bytes);
+					if (ret != bytes) {
 						//eprintf ("Cannot write at 0x%08" PFMT64x "\n", ptr);
 						esil->trap = 1;
 					}
-					ptr += 4;
+					ptr += bytes;
 					free (foo);
 				}
 			}
@@ -1481,9 +1477,11 @@ static int esil_peek_n(RAnalEsil *esil, int bits) {
 		return 0;
 	}
 	if (dst && isregornum (esil, dst, &addr)) {
-		ut64 a, b, bitmask = genmask (bits - 1);
-		ret = r_anal_esil_mem_read (esil, addr, (ut8 *)&a, bytes);
-		r_mem_copyendian ((ut8 *)&b, (const ut8 *)&a, bytes, !esil->anal->big_endian);
+		ut64 bitmask = genmask (bits - 1);
+		ut8 a[sizeof(ut64)];
+		ut64 b;
+		ret = r_anal_esil_mem_read (esil, addr, a, bytes);
+		b = r_read_ble64 (a, esil->anal->big_endian);
 		snprintf (res, sizeof (res), "0x%" PFMT64x, b & bitmask);
 		r_anal_esil_push (esil, res);
 		esil->lastsz = bits;
@@ -1521,20 +1519,21 @@ static int esil_peek_some(RAnalEsil *esil) {
 			isregornum (esil, count, &regs);
 			if (regs > 0) {
 				ut32 num32;
+				ut8 a[sizeof (ut32)];
 				for (i = 0; i < regs; i++) {
 					char *foo = r_anal_esil_pop (esil);
 					if (!foo) {
 						ERR ("Cannot pop in peek");
 						return 0;
 					}
-					ret = r_anal_esil_mem_read (esil, ptr,
-								(ut8 *)&num32, sizeof (num32));
-					if (ret == sizeof (num32)) {
+					ret = r_anal_esil_mem_read (esil, ptr, a, 4);
+					if (ret == sizeof (ut32)) {
+						num32 = r_read_ble32 (a, esil->anal->big_endian);
 						r_anal_esil_reg_write (esil, foo, num32);
 					} else {
 						eprintf ("Cannot peek from 0x%08" PFMT64x "\n", ptr);
 					}
-					ptr += 4;
+					ptr += sizeof (ut32);
 					free (foo);
 				}
 			}

libr/anal/fcn.c

@@ -229,9 +229,14 @@ static int try_walkthrough_jmptbl(RAnal *anal, RAnalFunction *fcn, int depth, ut
 	ut64 offs, sz = anal->bits >> 3;
 	if (!jmptbl) return 0;
 	anal->iob.read_at (anal->iob.io, ptr, jmptbl, MAX_JMPTBL_SIZE);
-	for (offs = 0; offs < MAX_JMPTBL_SIZE; offs += sz) {
-		ut64 jmpptr = 0;
-		r_mem_copyendian ((ut8*)&jmpptr, jmptbl + offs, sz, !anal->big_endian);
+	for (offs = 0; offs + sz - 1 < MAX_JMPTBL_SIZE; offs += sz) {
+		ut64 jmpptr;
+		switch (sz) {
+		case 1: jmpptr = r_read_le8 (jmptbl + offs); break;
+		case 2: jmpptr = r_read_le16 (jmptbl + offs); break;
+		case 4: jmpptr = r_read_le32 (jmptbl + offs); break;
+		default: jmpptr = r_read_le64 (jmptbl + offs); break;
+		}
 		if (anal->limit) {
 			if (jmpptr < anal->limit->from || jmpptr > anal->limit->to)
 				break;

libr/anal/p/anal_h8300.c

@@ -53,7 +53,7 @@ static void h8300_anal_jmp(RAnalOp *op, ut64 addr, const ut8 *buf) {
 		break;
 	case H8300_JMP_2:
 		op->type = R_ANAL_OP_TYPE_JMP;
-		r_mem_copyendian((ut8*)&ad, buf + 2, sizeof(ut16), !LIL_ENDIAN);
+		r_mem_swapendian ((ut8*)&ad, buf + 2, sizeof (ut16));
 		op->jump = ad;
 		break;
 	case H8300_JMP_3:
@@ -72,8 +72,7 @@ static void h8300_anal_jsr(RAnalOp *op, ut64 addr, const ut8 *buf) {
 		break;
 	case H8300_JSR_2:
 		op->type = R_ANAL_OP_TYPE_CALL;
-		r_mem_copyendian((ut8*)&ad, buf + 2,
-				sizeof(ut16), !LIL_ENDIAN);
+		r_mem_swapendian ((ut8*)&ad, buf + 2, sizeof (ut16));
 		op->jump = ad;
 		op->fail = addr + 4;
 		break;

libr/anal/p/anal_mips_gnu.c

@@ -19,9 +19,8 @@ static const char* mips_reg_decode(unsigned reg_num) {
 	return NULL;
 }
 
-static int mips_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *b_in, int len) {
+static int mips_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *b, int len) {
 	unsigned int opcode;
-	ut8 b[4];
 	// WIP char buf[10]; int reg; int family;
 	int optype, oplen = (anal->bits==16)?2:4;
 
@@ -35,10 +34,8 @@ static int mips_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *b_in, int len
 	op->addr = addr;
 	r_strbuf_init (&op->esil);
 
-	// Reminder: r_mem_copyendian swaps if arg `endian` ==0 ...
-	// When anal->big_endian is "false", as for mipsel architecture, we NEED to swap here for the below analysis to work.
-	r_mem_copyendian ((ut8*)&opcode, b_in, 4, anal->big_endian ? 1 : 0);
-	r_mem_copyendian (b, b_in, 4, anal->big_endian ? 1 : 0);
+	// Be endian aware
+	opcode = r_read_ble32 (b, anal->big_endian);
 
 	// eprintf ("MIPS: %02x %02x %02x %02x (after endian: big=%d)\n", b[0], b[1], b[2], b[3], anal->big_endian);
 	if (opcode == 0) {

libr/anal/p/anal_ppc_gnu.c

@@ -7,11 +7,8 @@
 
 // NOTE: buf should be at least 16 bytes!
 // XXX addr should be off_t for 64 love
-static int ppc_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *_bytes, int len) {
+static int ppc_op(RAnal *anal, RAnalOp *op, ut64 addr, const ut8 *bytes, int len) {
 //int arch_ppc_op(ut64 addr, const u8 *bytes, struct op_t *op)
-// TODO swap endian here??
-	char bytes[1024];
-	r_mem_copyendian ((ut8*)bytes, _bytes, 4, 1);
 	// XXX hack
 	int opcode = (bytes[0] & 0xf8) >> 3; // bytes 0-5
 	short baddr = ((bytes[2]<<8) | (bytes[3]&0xfc));// 16-29