Improve consitency throughout library/common.h

Replace the contents of MBEDTLS_PUT_UINTx_yz contained inconsitent
but similar/duplicate code to the MBEDTLS_BYTE_x macros. Therefore
the contents of the macros now utilise the byte reading macros.

MBEDTLS_PUT_UINT64_LE's written order was also not consitent with
the other PUT macros, so that was modified.

Documentation comment said LSB instead of MSB and that has also been
resolved.

Signed-off-by: Joe Subbiani <joe.subbiani@arm.com>
diff --git a/library/common.h b/library/common.h
index 3e8f88b..ba0396c 100644
--- a/library/common.h
+++ b/library/common.h
@@ -93,12 +93,12 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT32_BE
-#define MBEDTLS_GET_UINT32_BE( data , offset )              \
-    (                                                       \
-          ( (uint32_t) ( data )[( offset )    ] << 24 )     \
-        | ( (uint32_t) ( data )[( offset ) + 1] << 16 )     \
-        | ( (uint32_t) ( data )[( offset ) + 2] <<  8 )     \
-        | ( (uint32_t) ( data )[( offset ) + 3]       )     \
+#define MBEDTLS_GET_UINT32_BE( data , offset )                  \
+    (                                                           \
+          ( (uint32_t) ( data )[( offset )    ] << 24 )         \
+        | ( (uint32_t) ( data )[( offset ) + 1] << 16 )         \
+        | ( (uint32_t) ( data )[( offset ) + 2] <<  8 )         \
+        | ( (uint32_t) ( data )[( offset ) + 3]       )         \
     )
 #endif
 
@@ -112,13 +112,13 @@
  *                  byte of the 32 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT32_BE
-#define MBEDTLS_PUT_UINT32_BE( n, data, offset )                    \
-    do {                                                            \
-        ( data )[( offset )    ] = (unsigned char) ( (n) >> 24 );   \
-        ( data )[( offset ) + 1] = (unsigned char) ( (n) >> 16 );   \
-        ( data )[( offset ) + 2] = (unsigned char) ( (n) >>  8 );   \
-        ( data )[( offset ) + 3] = (unsigned char) ( (n)       );   \
-    } while( 0 )
+#define MBEDTLS_PUT_UINT32_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_0( n );             \
+}
 #endif
 
 /**
@@ -131,12 +131,12 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT32_LE
-#define MBEDTLS_GET_UINT32_LE( data, offset )              \
-    (                                                      \
-          ( (uint32_t) ( data )[( offset )    ]       )    \
-        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )    \
-        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )    \
-        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )    \
+#define MBEDTLS_GET_UINT32_LE( data, offset )                   \
+    (                                                           \
+          ( (uint32_t) ( data )[( offset )    ]       )         \
+        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )         \
+        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )         \
+        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )         \
     )
 #endif
 
@@ -150,13 +150,13 @@
  *                  byte of the 32 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT32_LE
-#define MBEDTLS_PUT_UINT32_LE( n, data, offset )                                \
-    do {                                                                        \
-        ( data )[( offset )    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
-        ( data )[( offset ) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
-        ( data )[( offset ) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF );    \
-        ( data )[( offset ) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF );    \
-    } while( 0 )
+#define MBEDTLS_PUT_UINT32_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
+}
 #endif
 
 /**
@@ -169,10 +169,10 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT16_LE
-#define MBEDTLS_GET_UINT16_LE( data, offset )               \
-    (                                                       \
-          ( (uint16_t) ( data )[( offset )    ]       )     \
-        | ( (uint16_t) ( data )[( offset ) + 1] <<  8 )     \
+#define MBEDTLS_GET_UINT16_LE( data, offset )                   \
+    (                                                           \
+          ( (uint16_t) ( data )[( offset )    ]       )         \
+        | ( (uint16_t) ( data )[( offset ) + 1] <<  8 )         \
     )
 #endif
 
@@ -186,16 +186,16 @@
  *                  byte of the 16 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT16_LE
-#define MBEDTLS_PUT_UINT16_LE( n, data, offset )                            \
-{                                                                           \
-    ( data )[( offset )    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
-    ( data )[( offset ) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
+#define MBEDTLS_PUT_UINT16_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
 }
 #endif
 
 /**
  * Get the unsigned 16 bits integer corresponding to two bytes in
- * big-endian order (LSB first).
+ * big-endian order (MSB first).
  *
  * \param   data    Base address of the memory to get the two bytes from.
  * \param   offset  Offset from \p base of the first and most significant
@@ -203,10 +203,10 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT16_BE
-#define MBEDTLS_GET_UINT16_BE( data, offset )              \
-    (                                                      \
-          ( (uint16_t) ( data )[( offset )    ] << 8 )     \
-        | ( (uint16_t) ( data )[( offset ) + 1]      )     \
+#define MBEDTLS_GET_UINT16_BE( data, offset )                   \
+    (                                                           \
+          ( (uint16_t) ( data )[( offset )    ] << 8 )          \
+        | ( (uint16_t) ( data )[( offset ) + 1]      )          \
     )
 #endif
 
@@ -220,10 +220,10 @@
  *                  byte of the 16 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT16_BE
-#define MBEDTLS_PUT_UINT16_BE( n, data, offset )                           \
-{                                                                          \
-    ( data )[( offset )    ] = (unsigned char) ( ( (n) >> 8 ) & 0xFF );    \
-    ( data )[( offset ) + 1] = (unsigned char) ( ( (n)      ) & 0xFF );    \
+#define MBEDTLS_PUT_UINT16_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_0( n );             \
 }
 #endif
 
@@ -237,16 +237,16 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT64_BE
-#define MBEDTLS_GET_UINT64_BE( data, offset )                 \
-    (                                                         \
-          ( (uint64_t) ( data )[( offset )    ] << 56 )       \
-        | ( (uint64_t) ( data )[( offset ) + 1] << 48 )       \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 40 )       \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 32 )       \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 24 )       \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 16 )       \
-        | ( (uint64_t) ( data )[( offset ) + 6] <<  8 )       \
-        | ( (uint64_t) ( data )[( offset ) + 7]       )       \
+#define MBEDTLS_GET_UINT64_BE( data, offset )                   \
+    (                                                           \
+          ( (uint64_t) ( data )[( offset )    ] << 56 )         \
+        | ( (uint64_t) ( data )[( offset ) + 1] << 48 )         \
+        | ( (uint64_t) ( data )[( offset ) + 2] << 40 )         \
+        | ( (uint64_t) ( data )[( offset ) + 3] << 32 )         \
+        | ( (uint64_t) ( data )[( offset ) + 4] << 24 )         \
+        | ( (uint64_t) ( data )[( offset ) + 5] << 16 )         \
+        | ( (uint64_t) ( data )[( offset ) + 6] <<  8 )         \
+        | ( (uint64_t) ( data )[( offset ) + 7]       )         \
     )
 #endif
 
@@ -260,16 +260,16 @@
  *                  byte of the 64 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT64_BE
-#define MBEDTLS_PUT_UINT64_BE( n, data, offset )                    \
-{                                                                   \
-    ( data )[( offset )    ] = (unsigned char) ( (n) >> 56 );       \
-    ( data )[( offset ) + 1] = (unsigned char) ( (n) >> 48 );       \
-    ( data )[( offset ) + 2] = (unsigned char) ( (n) >> 40 );       \
-    ( data )[( offset ) + 3] = (unsigned char) ( (n) >> 32 );       \
-    ( data )[( offset ) + 4] = (unsigned char) ( (n) >> 24 );       \
-    ( data )[( offset ) + 5] = (unsigned char) ( (n) >> 16 );       \
-    ( data )[( offset ) + 6] = (unsigned char) ( (n) >>  8 );       \
-    ( data )[( offset ) + 7] = (unsigned char) ( (n)       );       \
+#define MBEDTLS_PUT_UINT64_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_7( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_6( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_5( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_4( n );             \
+    ( data )[( offset ) + 4] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 5] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 6] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 7] = MBEDTLS_BYTE_0( n );             \
 }
 #endif
 
@@ -283,16 +283,16 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT64_LE
-#define MBEDTLS_GET_UINT64_LE( data, offset )               \
-    (                                                       \
-          ( (uint64_t) ( data )[( offset ) + 7] << 56 )     \
-        | ( (uint64_t) ( data )[( offset ) + 6] << 48 )     \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 40 )     \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 32 )     \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 24 )     \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 16 )     \
-        | ( (uint64_t) ( data )[( offset ) + 1] <<  8 )     \
-        | ( (uint64_t) ( data )[( offset )    ]       )     \
+#define MBEDTLS_GET_UINT64_LE( data, offset )                   \
+    (                                                           \
+          ( (uint64_t) ( data )[( offset ) + 7] << 56 )         \
+        | ( (uint64_t) ( data )[( offset ) + 6] << 48 )         \
+        | ( (uint64_t) ( data )[( offset ) + 5] << 40 )         \
+        | ( (uint64_t) ( data )[( offset ) + 4] << 32 )         \
+        | ( (uint64_t) ( data )[( offset ) + 3] << 24 )         \
+        | ( (uint64_t) ( data )[( offset ) + 2] << 16 )         \
+        | ( (uint64_t) ( data )[( offset ) + 1] <<  8 )         \
+        | ( (uint64_t) ( data )[( offset )    ]       )         \
     )
 #endif
 
@@ -306,16 +306,16 @@
  *                  byte of the 64 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT64_LE
-#define MBEDTLS_PUT_UINT64_LE( n, data, offset )                    \
-{                                                                   \
-    ( data )[( offset ) + 7] = (unsigned char) ( (n) >> 56 );       \
-    ( data )[( offset ) + 6] = (unsigned char) ( (n) >> 48 );       \
-    ( data )[( offset ) + 5] = (unsigned char) ( (n) >> 40 );       \
-    ( data )[( offset ) + 4] = (unsigned char) ( (n) >> 32 );       \
-    ( data )[( offset ) + 3] = (unsigned char) ( (n) >> 24 );       \
-    ( data )[( offset ) + 2] = (unsigned char) ( (n) >> 16 );       \
-    ( data )[( offset ) + 1] = (unsigned char) ( (n) >>  8 );       \
-    ( data )[( offset )    ] = (unsigned char) ( (n)       );       \
+#define MBEDTLS_PUT_UINT64_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 4] = MBEDTLS_BYTE_4( n );             \
+    ( data )[( offset ) + 5] = MBEDTLS_BYTE_5( n );             \
+    ( data )[( offset ) + 6] = MBEDTLS_BYTE_6( n );             \
+    ( data )[( offset ) + 7] = MBEDTLS_BYTE_7( n );             \
 }
 #endif