code style

Signed-off-by: Dave Rodgman <dave.rodgman@arm.com>

Author: daverodgman

drivers/builtin/src/aesce.c

@@ -182,8 +182,8 @@ int mbedtls_aesce_has_support_impl(void)
 
 
 static inline uint8x16_t aesce_encrypt_block_inline(uint8x16_t block,
-                                      const uint8x16_t *vkeys,
-                                      int nr)
+                                                    const uint8x16_t *vkeys,
+                                                    int nr)
 {
     /* 10, 12 or 14 rounds. Unroll loop. */
 #if defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
@@ -210,8 +210,8 @@ static inline uint8x16_t aesce_encrypt_block_inline(uint8x16_t block,
 }
 
 static NO_INLINE uint8x16_t aesce_encrypt_block(uint8x16_t block,
-                                      const uint8x16_t *vkeys,
-                                      const int nr)
+                                                const uint8x16_t *vkeys,
+                                                const int nr)
 {
     return aesce_encrypt_block_inline(block, vkeys, nr);
 }
@@ -781,16 +781,17 @@ static inline uint8x16_t poly_mult_reduce(uint8x16x4_t input)
 }
 
 // Having a not-inlined copy helps code-size on non-perf-sensitive paths
-static NO_INLINE uint8x16_t poly_mult_multiply_and_reduce(uint8x16_t a, uint8x16_t b) {
-    return poly_mult_reduce(poly_mult_128(a,b));
+static NO_INLINE uint8x16_t poly_mult_multiply_and_reduce(uint8x16_t a, uint8x16_t b)
+{
+    return poly_mult_reduce(poly_mult_128(a, b));
 }
 
 /*
  * GCM multiplication: c = a times b in GF(2^128)
  */
 NO_INLINE void mbedtls_aesce_gcm_mult(unsigned char c[16],
-                            const unsigned char a[16],
-                            const unsigned char b[16])
+                                      const unsigned char a[16],
+                                      const unsigned char b[16])
 {
     uint8x16_t va, vb, vc;
     va = vrbitq_u8(vld1q_u8(&a[0]));
@@ -848,7 +849,8 @@ void mbedtls_aesce_gcm_update_block_partial(
     const uint8_t *input,
     uint8_t *output,
     unsigned offset, unsigned len, uint8_t scratch[32]
-) {
+    )
+{
     MBEDTLS_ASSUME(len > 0);
     int nr = MBEDTLS_AES_GET_NR(aes_ctx);
     const uint8x16_t *vkeys = aes_ctx->vkeys;
@@ -901,11 +903,11 @@ void mbedtls_aesce_gcm_update_block_partial(
 
 MBEDTLS_OPTIMIZE_FOR_PERFORMANCE
 void mbedtls_aesce_gcm_update_blocks(
-                        mbedtls_aes_context *aes_ctx,
-                        mbedtls_gcm_context *ctx,
-                        const unsigned char *input,
-                        unsigned char *output,
-                        size_t blocks)
+    mbedtls_aes_context *aes_ctx,
+    mbedtls_gcm_context *ctx,
+    const unsigned char *input,
+    unsigned char *output,
+    size_t blocks)
 {
     const uint8x16_t *vkeys = aes_ctx->vkeys;
 
@@ -927,7 +929,9 @@ void mbedtls_aesce_gcm_update_blocks(
     MBEDTLS_MAYBE_UNUSED const uint8x16x4_t vh = ctx->vghash_4;
 
     // compute keystream in ve
-    for (size_t b = 0; b < (blocks - (blocks % MBEDTLS_AESCE_GCM_MULTIBLOCK)); b += MBEDTLS_AESCE_GCM_MULTIBLOCK) {
+    for (size_t b = 0;
+         b < (blocks - (blocks % MBEDTLS_AESCE_GCM_MULTIBLOCK));
+         b += MBEDTLS_AESCE_GCM_MULTIBLOCK) {
         // manually unrolling and ordering instructions makes a big difference
         // to performance (esp. GCC), and also a small size benefit.
 
@@ -1026,7 +1030,7 @@ void mbedtls_aesce_gcm_update_blocks(
             vtag = poly_mult_reduce(tag_x4);
         }
     #else
-        uint8x16_t ct0,ct1,ct2,ct3;
+        uint8x16_t ct0, ct1, ct2, ct3;
         if (mode == MBEDTLS_AES_ENCRYPT) {
             ct0 = vout[0];
             ct1 = vout[1];
@@ -1076,7 +1080,7 @@ void mbedtls_aesce_gcm_update_blocks(
                 0,
                 16,
                 scratch
-            );
+                );
             input += 16;
             output += 16;
         }

drivers/builtin/src/aesce.h

@@ -120,11 +120,11 @@ int mbedtls_aesce_crypt_ecb(mbedtls_aes_context *ctx,
 #if MBEDTLS_AESCE_OPTIMISE_FOR_SIZE == 0
 
 void mbedtls_aesce_gcm_update_blocks(
-                       mbedtls_aes_context *aes_ctx,
-                       mbedtls_gcm_context *ctx,
-                       const unsigned char *input,
-                       unsigned char *output,
-                       size_t blocks);
+    mbedtls_aes_context *aes_ctx,
+    mbedtls_gcm_context *ctx,
+    const unsigned char *input,
+    unsigned char *output,
+    size_t blocks);
 
 #endif // MBEDTLS_AESCE_OPTIMISE_FOR_SIZE
 
@@ -146,7 +146,7 @@ void mbedtls_aesce_gcm_update_block_partial(
     unsigned offset,
     unsigned length,
     uint8_t scratch[32]
-);
+    );
 
 #if !defined(MBEDTLS_BLOCK_CIPHER_NO_DECRYPT)
 /**

drivers/builtin/src/gcm.c

@@ -601,7 +601,8 @@ static int gcm_mask(mbedtls_gcm_context *ctx,
     };
     uint8_t **ap = (ctx->mode == MBEDTLS_GCM_DECRYPT) ? &ps[0] : &ps[3];
     for (unsigned i = 0; i < 6; i += 3) {
-        mbedtls_xor_no_simd(ap[i], (const uint8_t *) ap[i + 1], (const uint8_t *) ap[i + 2], use_len);
+        mbedtls_xor_no_simd(ap[i], (const uint8_t *) ap[i + 1], (const uint8_t *) ap[i + 2],
+                            use_len);
     }
 
     return 0;
@@ -663,7 +664,13 @@ int mbedtls_gcm_update(mbedtls_gcm_context *ctx,
 
 #if defined(MBEDTLS_AESCE_HAVE_CODE) && defined(MBEDTLS_AES_C)
         if (use_aesce) {
-            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx), ctx, p, out_p, offset, use_len, scratch);
+            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx),
+                                                   ctx,
+                                                   p,
+                                                   out_p,
+                                                   offset,
+                                                   use_len,
+                                                   scratch);
         } else
 #endif
         {
@@ -689,7 +696,13 @@ int mbedtls_gcm_update(mbedtls_gcm_context *ctx,
         size_t blocks = input_length / 16;
 #if MBEDTLS_AESCE_OPTIMISE_FOR_SIZE == 1
         for (size_t i = 0; i < blocks; i++) {
-            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx), ctx, p + i * 16, out_p + i * 16, 0, 16, scratch);
+            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx),
+                                                   ctx,
+                                                   p + i * 16,
+                                                   out_p + i * 16,
+                                                   0,
+                                                   16,
+                                                   scratch);
         }
 #else
         mbedtls_aesce_gcm_update_blocks(GCM_GET_AES_CTX(ctx), ctx, p, out_p, blocks);
@@ -717,7 +730,13 @@ int mbedtls_gcm_update(mbedtls_gcm_context *ctx,
     if (input_length > 0) {
 #if defined(MBEDTLS_AESCE_HAVE_CODE) && defined(MBEDTLS_AES_C)
         if (use_aesce) {
-            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx), ctx, p, out_p, 0, input_length, scratch);
+            mbedtls_aesce_gcm_update_block_partial(GCM_GET_AES_CTX(ctx),
+                                                   ctx,
+                                                   p,
+                                                   out_p,
+                                                   0,
+                                                   input_length,
+                                                   scratch);
         } else
 #endif
         {