qemu-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency t


From: no-reply
Subject: Re: [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests
Date: Sat, 20 Aug 2016 14:19:48 -0700 (PDT)

Hi,

Your series seems to have some coding style problems. See output below for
more information:

Message-id: address@hidden
Subject: [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency 
tests
Type: series

=== TEST SCRIPT BEGIN ===
#!/bin/bash

BASE=base
n=1
total=$(git log --oneline $BASE.. | wc -l)
failed=0

# Useful git options
git config --local diff.renamelimit 0
git config --local diff.renames True

commits="$(git log --format=%H --reverse $BASE..)"
for c in $commits; do
    echo "Checking PATCH $n/$total: $(git show --no-patch --format=%s $c)..."
    if ! git show $c --format=email | ./scripts/checkpatch.pl --mailback -; then
        failed=1
        echo
    fi
    n=$((n+1))
done

exit $failed
=== TEST SCRIPT END ===

Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
From https://github.com/patchew-project/qemu
 * [new tag]         patchew/address@hidden -> patchew/address@hidden
Switched to a new branch 'test'
fa48cbf travis: Enable litmus tests
863855b tests/tcg: Add aarch64 litmus tests
c0bb07a tests/tcg: Add i386 litmus test

=== OUTPUT BEGIN ===
Checking PATCH 1/3: tests/tcg: Add i386 litmus test...
ERROR: trailing whitespace
#65: FILE: tests/tcg/i386/litmus/README.txt:1:
+Tests produced by litmus for architecture X86 on linux $

ERROR: space required after that ',' (ctx:VxV)
#125: FILE: tests/tcg/i386/litmus/SAL.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#134: FILE: tests/tcg/i386/litmus/SAL.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#134: FILE: tests/tcg/i386/litmus/SAL.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#134: FILE: tests/tcg/i386/litmus/SAL.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#135: FILE: tests/tcg/i386/litmus/SAL.c:43:
+  asm __volatile__ ("mfence" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#135: FILE: tests/tcg/i386/litmus/SAL.c:43:
+  asm __volatile__ ("mfence" ::: "memory");
                                ^

WARNING: line over 80 characters
#139: FILE: tests/tcg/i386/litmus/SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#139: FILE: tests/tcg/i386/litmus/SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#139: FILE: tests/tcg/i386/litmus/SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#139: FILE: tests/tcg/i386/litmus/SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#139: FILE: tests/tcg/i386/litmus/SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#143: FILE: tests/tcg/i386/litmus/SAL.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#143: FILE: tests/tcg/i386/litmus/SAL.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#162: FILE: tests/tcg/i386/litmus/SAL.c:70:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#169: FILE: tests/tcg/i386/litmus/SAL.c:77:
+inline static int final_cond(int _out_0_eax,int _out_1_eax) {

ERROR: space required after that ',' (ctx:VxV)
#169: FILE: tests/tcg/i386/litmus/SAL.c:77:
+inline static int final_cond(int _out_0_eax,int _out_1_eax) {
                                            ^

ERROR: storage class should be at the beginning of the declaration
#169: FILE: tests/tcg/i386/litmus/SAL.c:77:
+inline static int final_cond(int _out_0_eax,int _out_1_eax) {

ERROR: inline keyword should sit between storage class and type
#169: FILE: tests/tcg/i386/litmus/SAL.c:77:
+inline static int final_cond(int _out_0_eax,int _out_1_eax) {

ERROR: open brace '{' following function declarations go on the next line
#183: FILE: tests/tcg/i386/litmus/SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#183: FILE: tests/tcg/i386/litmus/SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#183: FILE: tests/tcg/i386/litmus/SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#193: FILE: tests/tcg/i386/litmus/SAL.c:101:
+static const int out_0_eax_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#199: FILE: tests/tcg/i386/litmus/SAL.c:107:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#202: FILE: tests/tcg/i386/litmus/SAL.c:110:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#209: FILE: tests/tcg/i386/litmus/SAL.c:117:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#214: FILE: tests/tcg/i386/litmus/SAL.c:122:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#215: FILE: tests/tcg/i386/litmus/SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#215: FILE: tests/tcg/i386/litmus/SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#215: FILE: tests/tcg/i386/litmus/SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#215: FILE: tests/tcg/i386/litmus/SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#218: FILE: tests/tcg/i386/litmus/SAL.c:126:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#221: FILE: tests/tcg/i386/litmus/SAL.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#221: FILE: tests/tcg/i386/litmus/SAL.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#224: FILE: tests/tcg/i386/litmus/SAL.c:132:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#229: FILE: tests/tcg/i386/litmus/SAL.c:137:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);
                                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/i386/litmus/SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:EAX=%i; 1:EAX=%i;\n",c,show ? '*' : 
':',(int)o[out_0_eax_f],(int)o[out_1_eax_f]);
                                                                                
           ^

ERROR: open brace '{' following function declarations go on the next line
#233: FILE: tests/tcg/i386/litmus/SAL.c:141:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#235: FILE: tests/tcg/i386/litmus/SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#235: FILE: tests/tcg/i386/litmus/SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#235: FILE: tests/tcg/i386/litmus/SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#235: FILE: tests/tcg/i386/litmus/SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#242: FILE: tests/tcg/i386/litmus/SAL.c:150:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#246: FILE: tests/tcg/i386/litmus/SAL.c:154:
+  _a->out_0_eax = malloc_check(size_of_test*sizeof(*(_a->out_0_eax)));
                                            ^

ERROR: spaces required around that '*' (ctx:VxV)
#247: FILE: tests/tcg/i386/litmus/SAL.c:155:
+  _a->out_1_eax = malloc_check(size_of_test*sizeof(*(_a->out_1_eax)));
                                            ^

ERROR: spaces required around that '*' (ctx:VxV)
#248: FILE: tests/tcg/i386/litmus/SAL.c:156:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#249: FILE: tests/tcg/i386/litmus/SAL.c:157:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#251: FILE: tests/tcg/i386/litmus/SAL.c:159:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#254: FILE: tests/tcg/i386/litmus/SAL.c:162:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#263: FILE: tests/tcg/i386/litmus/SAL.c:171:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#264: FILE: tests/tcg/i386/litmus/SAL.c:172:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#277: FILE: tests/tcg/i386/litmus/SAL.c:185:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#280: FILE: tests/tcg/i386/litmus/SAL.c:188:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: trailing statements should be on next line
#281: FILE: tests/tcg/i386/litmus/SAL.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#281: FILE: tests/tcg/i386/litmus/SAL.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals 
failed");
[...]

ERROR: trailing statements should be on next line
#282: FILE: tests/tcg/i386/litmus/SAL.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#282: FILE: tests/tcg/i386/litmus/SAL.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#301: FILE: tests/tcg/i386/litmus/SAL.c:209:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#306: FILE: tests/tcg/i386/litmus/SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#306: FILE: tests/tcg/i386/litmus/SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#306: FILE: tests/tcg/i386/litmus/SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#309: FILE: tests/tcg/i386/litmus/SAL.c:217:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#314: FILE: tests/tcg/i386/litmus/SAL.c:222:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#314: FILE: tests/tcg/i386/litmus/SAL.c:222:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#315: FILE: tests/tcg/i386/litmus/SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#315: FILE: tests/tcg/i386/litmus/SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#315: FILE: tests/tcg/i386/litmus/SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#326: FILE: tests/tcg/i386/litmus/SAL.c:234:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_0_eax[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#326: FILE: tests/tcg/i386/litmus/SAL.c:234:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_0_eax[_i])
                      ^

ERROR: space required after that ',' (ctx:VxV)
#326: FILE: tests/tcg/i386/litmus/SAL.c:234:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_0_eax[_i])
                                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#328: FILE: tests/tcg/i386/litmus/SAL.c:236:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#328: FILE: tests/tcg/i386/litmus/SAL.c:236:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#336: FILE: tests/tcg/i386/litmus/SAL.c:244:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#341: FILE: tests/tcg/i386/litmus/SAL.c:249:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#341: FILE: tests/tcg/i386/litmus/SAL.c:249:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#341: FILE: tests/tcg/i386/litmus/SAL.c:249:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#344: FILE: tests/tcg/i386/litmus/SAL.c:252:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#349: FILE: tests/tcg/i386/litmus/SAL.c:257:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#349: FILE: tests/tcg/i386/litmus/SAL.c:257:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#350: FILE: tests/tcg/i386/litmus/SAL.c:258:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#350: FILE: tests/tcg/i386/litmus/SAL.c:258:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#350: FILE: tests/tcg/i386/litmus/SAL.c:258:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#361: FILE: tests/tcg/i386/litmus/SAL.c:269:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_1_eax[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#361: FILE: tests/tcg/i386/litmus/SAL.c:269:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_1_eax[_i])
                      ^

ERROR: space required after that ',' (ctx:VxV)
#361: FILE: tests/tcg/i386/litmus/SAL.c:269:
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_1_eax[_i])
                                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#363: FILE: tests/tcg/i386/litmus/SAL.c:271:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#363: FILE: tests/tcg/i386/litmus/SAL.c:271:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#381: FILE: tests/tcg/i386/litmus/SAL.c:289:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#387: FILE: tests/tcg/i386/litmus/SAL.c:295:
+  f_t *fun[] = {&P0,&P1};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#387: FILE: tests/tcg/i386/litmus/SAL.c:295:
+  f_t *fun[] = {&P0,&P1};
                     ^

ERROR: spaces required around that '-' (ctx:VxV)
#393: FILE: tests/tcg/i386/litmus/SAL.c:301:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#399: FILE: tests/tcg/i386/litmus/SAL.c:307:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#401: FILE: tests/tcg/i386/litmus/SAL.c:309:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#405: FILE: tests/tcg/i386/litmus/SAL.c:313:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#405: FILE: tests/tcg/i386/litmus/SAL.c:313:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#405: FILE: tests/tcg/i386/litmus/SAL.c:313:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#405: FILE: tests/tcg/i386/litmus/SAL.c:313:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#407: FILE: tests/tcg/i386/litmus/SAL.c:315:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#407: FILE: tests/tcg/i386/litmus/SAL.c:315:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#407: FILE: tests/tcg/i386/litmus/SAL.c:315:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#407: FILE: tests/tcg/i386/litmus/SAL.c:315:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#408: FILE: tests/tcg/i386/litmus/SAL.c:316:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#408: FILE: tests/tcg/i386/litmus/SAL.c:316:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#409: FILE: tests/tcg/i386/litmus/SAL.c:317:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#409: FILE: tests/tcg/i386/litmus/SAL.c:317:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#409: FILE: tests/tcg/i386/litmus/SAL.c:317:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#411: FILE: tests/tcg/i386/litmus/SAL.c:319:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#411: FILE: tests/tcg/i386/litmus/SAL.c:319:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#411: FILE: tests/tcg/i386/litmus/SAL.c:319:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#411: FILE: tests/tcg/i386/litmus/SAL.c:319:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#412: FILE: tests/tcg/i386/litmus/SAL.c:320:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#412: FILE: tests/tcg/i386/litmus/SAL.c:320:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#416: FILE: tests/tcg/i386/litmus/SAL.c:324:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_0_eax_i = ctx.out_0_eax[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#416: FILE: tests/tcg/i386/litmus/SAL.c:324:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#422: FILE: tests/tcg/i386/litmus/SAL.c:330:
+      cond = final_ok(final_cond(_out_0_eax_i,_out_1_eax_i));
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#425: FILE: tests/tcg/i386/litmus/SAL.c:333:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#425: FILE: tests/tcg/i386/litmus/SAL.c:333:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#425: FILE: tests/tcg/i386/litmus/SAL.c:333:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#426: FILE: tests/tcg/i386/litmus/SAL.c:334:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#436: FILE: tests/tcg/i386/litmus/SAL.c:344:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#437: FILE: tests/tcg/i386/litmus/SAL.c:345:
+  fprintf(out,"Test SAL Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#438: FILE: tests/tcg/i386/litmus/SAL.c:346:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#438: FILE: tests/tcg/i386/litmus/SAL.c:346:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#439: FILE: tests/tcg/i386/litmus/SAL.c:347:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#441: FILE: tests/tcg/i386/litmus/SAL.c:349:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#441: FILE: tests/tcg/i386/litmus/SAL.c:349:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#441: FILE: tests/tcg/i386/litmus/SAL.c:349:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#441: FILE: tests/tcg/i386/litmus/SAL.c:349:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#442: FILE: tests/tcg/i386/litmus/SAL.c:350:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#443: FILE: tests/tcg/i386/litmus/SAL.c:351:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#443: FILE: tests/tcg/i386/litmus/SAL.c:351:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#443: FILE: tests/tcg/i386/litmus/SAL.c:351:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#444: FILE: tests/tcg/i386/litmus/SAL.c:352:
+  fprintf(out,"Condition ~exists (0:EAX=0 /\\ 1:EAX=0) is %svalidated\n",cond 
? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#444: FILE: tests/tcg/i386/litmus/SAL.c:352:
+  fprintf(out,"Condition ~exists (0:EAX=0 /\\ 1:EAX=0) is %svalidated\n",cond 
? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#444: FILE: tests/tcg/i386/litmus/SAL.c:352:
+  fprintf(out,"Condition ~exists (0:EAX=0 /\\ 1:EAX=0) is %svalidated\n",cond 
? "" : "NOT ");
                                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#445: FILE: tests/tcg/i386/litmus/SAL.c:353:
+  fprintf(out,"Hash=d8f89591b2adad11d42d3eeb22d212c6\n");
              ^

ERROR: line over 90 characters
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                         ^

ERROR: space required before that '!' (ctx:OxV)
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                          ^

ERROR: space required after that ',' (ctx:VxV)
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#448: FILE: tests/tcg/i386/litmus/SAL.c:356:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                               ^

ERROR: suspect code indent for conditional statements (2, 2)
#449: FILE: tests/tcg/i386/litmus/SAL.c:357:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#451: FILE: tests/tcg/i386/litmus/SAL.c:359:
+  fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#451: FILE: tests/tcg/i386/litmus/SAL.c:359:
+  fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
                                ^

ERROR: open brace '{' following function declarations go on the next line
#456: FILE: tests/tcg/i386/litmus/SAL.c:364:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#456: FILE: tests/tcg/i386/litmus/SAL.c:364:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#456: FILE: tests/tcg/i386/litmus/SAL.c:364:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#465: FILE: tests/tcg/i386/litmus/SAL.c:373:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#465: FILE: tests/tcg/i386/litmus/SAL.c:373:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#468: FILE: tests/tcg/i386/litmus/SAL.c:376:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#468: FILE: tests/tcg/i386/litmus/SAL.c:376:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#468: FILE: tests/tcg/i386/litmus/SAL.c:376:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#468: FILE: tests/tcg/i386/litmus/SAL.c:376:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#477: FILE: tests/tcg/i386/litmus/SAL.c:385:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#477: FILE: tests/tcg/i386/litmus/SAL.c:385:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#477: FILE: tests/tcg/i386/litmus/SAL.c:385:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#477: FILE: tests/tcg/i386/litmus/SAL.c:385:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#481: FILE: tests/tcg/i386/litmus/SAL.c:389:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#484: FILE: tests/tcg/i386/litmus/SAL.c:392:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#484: FILE: tests/tcg/i386/litmus/SAL.c:392:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#484: FILE: tests/tcg/i386/litmus/SAL.c:392:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                         ^

ERROR: space prohibited after that open parenthesis '('
#484: FILE: tests/tcg/i386/litmus/SAL.c:392:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#485: FILE: tests/tcg/i386/litmus/SAL.c:393:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#486: FILE: tests/tcg/i386/litmus/SAL.c:394:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#487: FILE: tests/tcg/i386/litmus/SAL.c:395:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#487: FILE: tests/tcg/i386/litmus/SAL.c:395:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#488: FILE: tests/tcg/i386/litmus/SAL.c:396:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#490: FILE: tests/tcg/i386/litmus/SAL.c:398:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#492: FILE: tests/tcg/i386/litmus/SAL.c:400:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#496: FILE: tests/tcg/i386/litmus/SAL.c:404:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#501: FILE: tests/tcg/i386/litmus/SAL.c:409:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#506: FILE: tests/tcg/i386/litmus/SAL.c:414:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#514: FILE: tests/tcg/i386/litmus/SAL.c:422:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#514: FILE: tests/tcg/i386/litmus/SAL.c:422:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#514: FILE: tests/tcg/i386/litmus/SAL.c:422:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#519: FILE: tests/tcg/i386/litmus/SAL.c:427:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#519: FILE: tests/tcg/i386/litmus/SAL.c:427:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#519: FILE: tests/tcg/i386/litmus/SAL.c:427:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#521: FILE: tests/tcg/i386/litmus/SAL.c:429:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#524: FILE: tests/tcg/i386/litmus/SAL.c:432:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#527: FILE: tests/tcg/i386/litmus/SAL.c:435:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#530: FILE: tests/tcg/i386/litmus/SAL.c:438:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#533: FILE: tests/tcg/i386/litmus/SAL.c:441:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#539: FILE: tests/tcg/i386/litmus/SAL.c:447:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#540: FILE: tests/tcg/i386/litmus/SAL.c:448:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#540: FILE: tests/tcg/i386/litmus/SAL.c:448:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#547: FILE: tests/tcg/i386/litmus/SAL.c:455:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#549: FILE: tests/tcg/i386/litmus/SAL.c:457:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("SAL, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#552: FILE: tests/tcg/i386/litmus/SAL.c:460:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#565: FILE: tests/tcg/i386/litmus/SAL.c:473:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#565: FILE: tests/tcg/i386/litmus/SAL.c:473:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#565: FILE: tests/tcg/i386/litmus/SAL.c:473:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#565: FILE: tests/tcg/i386/litmus/SAL.c:473:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#565: FILE: tests/tcg/i386/litmus/SAL.c:473:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#571: FILE: tests/tcg/i386/litmus/SAL.c:479:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#572: FILE: tests/tcg/i386/litmus/SAL.c:480:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#577: FILE: tests/tcg/i386/litmus/SAL.c:485:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#579: FILE: tests/tcg/i386/litmus/SAL.c:487:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#579: FILE: tests/tcg/i386/litmus/SAL.c:487:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#579: FILE: tests/tcg/i386/litmus/SAL.c:487:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#579: FILE: tests/tcg/i386/litmus/SAL.c:487:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#579: FILE: tests/tcg/i386/litmus/SAL.c:487:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#580: FILE: tests/tcg/i386/litmus/SAL.c:488:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#580: FILE: tests/tcg/i386/litmus/SAL.c:488:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#581: FILE: tests/tcg/i386/litmus/SAL.c:489:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#581: FILE: tests/tcg/i386/litmus/SAL.c:489:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: open brace '{' following function declarations go on the next line
#612: FILE: tests/tcg/i386/litmus/affinity.c:23:
+cpus_t *read_affinity(void) {

ERROR: trailing whitespace
#616: FILE: tests/tcg/i386/litmus/affinity.c:27:
+  $

ERROR: trailing whitespace
#617: FILE: tests/tcg/i386/litmus/affinity.c:28:
+  if (res != 0) { $

ERROR: space required after that ',' (ctx:VxV)
#618: FILE: tests/tcg/i386/litmus/affinity.c:29:
+    errexit("pthread_getaffinity_np",res);
                                     ^

ERROR: spaces required around that '=' (ctx:VxV)
#620: FILE: tests/tcg/i386/litmus/affinity.c:31:
+  for (int p=0 ; p <  CPU_SETSIZE ; p++) {
             ^

ERROR: space required after that ',' (ctx:VxO)
#621: FILE: tests/tcg/i386/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
                    ^

ERROR: space required before that '&' (ctx:OxV)
#621: FILE: tests/tcg/i386/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
                     ^

ERROR: trailing statements should be on next line
#621: FILE: tests/tcg/i386/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;

ERROR: braces {} are necessary for all arms of this statement
#621: FILE: tests/tcg/i386/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
[...]

ERROR: spaces required around that '=' (ctx:VxV)
#625: FILE: tests/tcg/i386/litmus/affinity.c:36:
+  for (int p=0, *q=r->cpu ; p <  CPU_SETSIZE ; p++) {
             ^

ERROR: spaces required around that '=' (ctx:VxV)
#625: FILE: tests/tcg/i386/litmus/affinity.c:36:
+  for (int p=0, *q=r->cpu ; p <  CPU_SETSIZE ; p++) {
                   ^

ERROR: space required after that ',' (ctx:VxO)
#626: FILE: tests/tcg/i386/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
                    ^

ERROR: space required before that '&' (ctx:OxV)
#626: FILE: tests/tcg/i386/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
                     ^

ERROR: trailing statements should be on next line
#626: FILE: tests/tcg/i386/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;

ERROR: braces {} are necessary for all arms of this statement
#626: FILE: tests/tcg/i386/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
[...]

ERROR: storage class should be at the beginning of the declaration
#637: FILE: tests/tcg/i386/litmus/affinity.c:48:
+const static tsc_t sec = (tsc_t)1000000 ;

ERROR: "foo* bar" should be "foo *bar"
#639: FILE: tests/tcg/i386/litmus/affinity.c:50:
+static void* loop(void *p)  {

ERROR: open brace '{' following function declarations go on the next line
#639: FILE: tests/tcg/i386/litmus/affinity.c:50:
+static void* loop(void *p)  {

ERROR: trailing statements should be on next line
#642: FILE: tests/tcg/i386/litmus/affinity.c:53:
+  while (timeofday() < max) ;

ERROR: braces {} are necessary even for single statement blocks
#642: FILE: tests/tcg/i386/litmus/affinity.c:53:
+  while (timeofday() < max) ;

ERROR: open brace '{' following function declarations go on the next line
#647: FILE: tests/tcg/i386/litmus/affinity.c:58:
+static void warm_up(int sz, tsc_t d) {

ERROR: trailing statements should be on next line
#650: FILE: tests/tcg/i386/litmus/affinity.c:61:
+    for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;

ERROR: braces {} are necessary even for single statement blocks
#650: FILE: tests/tcg/i386/litmus/affinity.c:61:
+    for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;

ERROR: trailing statements should be on next line
#651: FILE: tests/tcg/i386/litmus/affinity.c:62:
+    for (int k = 0 ; k < sz ; k++) join(&th[k]) ;

ERROR: braces {} are necessary even for single statement blocks
#651: FILE: tests/tcg/i386/litmus/affinity.c:62:
+    for (int k = 0 ; k < sz ; k++) join(&th[k]) ;

ERROR: open brace '{' following function declarations go on the next line
#655: FILE: tests/tcg/i386/litmus/affinity.c:66:
+cpus_t *read_force_affinity(int n_avail, int verbose) {

ERROR: spaces required around that '+' (ctx:VxV)
#660: FILE: tests/tcg/i386/litmus/affinity.c:71:
+    warm_up(sz+1,max) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#660: FILE: tests/tcg/i386/litmus/affinity.c:71:
+    warm_up(sz+1,max) ;
                 ^

ERROR: trailing statements should be on next line
#662: FILE: tests/tcg/i386/litmus/affinity.c:73:
+    if (n_avail <= r->sz) return r ;

ERROR: braces {} are necessary for all arms of this statement
#662: FILE: tests/tcg/i386/litmus/affinity.c:73:
+    if (n_avail <= r->sz) return r ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#663: FILE: tests/tcg/i386/litmus/affinity.c:74:
+    if (verbose) {
+      fprintf(stderr,"Read affinity: '") ;

ERROR: space required after that ',' (ctx:VxV)
#664: FILE: tests/tcg/i386/litmus/affinity.c:75:
+      fprintf(stderr,"Read affinity: '") ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#665: FILE: tests/tcg/i386/litmus/affinity.c:76:
+      cpus_dump(stderr,r) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#666: FILE: tests/tcg/i386/litmus/affinity.c:77:
+      fprintf(stderr,"'\n") ;
                     ^

ERROR: trailing whitespace
#679: FILE: tests/tcg/i386/litmus/affinity.c:90:
+ $

ERROR: open brace '{' following function declarations go on the next line
#681: FILE: tests/tcg/i386/litmus/affinity.c:92:
+void write_affinity(cpus_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#687: FILE: tests/tcg/i386/litmus/affinity.c:98:
+    if (p->cpu[k] >= 0) {
+      CPU_SET(p->cpu[k],&mask) ;

ERROR: space required after that ',' (ctx:VxO)
#688: FILE: tests/tcg/i386/litmus/affinity.c:99:
+      CPU_SET(p->cpu[k],&mask) ;
                        ^

ERROR: space required before that '&' (ctx:OxV)
#688: FILE: tests/tcg/i386/litmus/affinity.c:99:
+      CPU_SET(p->cpu[k],&mask) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#693: FILE: tests/tcg/i386/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                  ^

ERROR: space required after that ',' (ctx:VxO)
#693: FILE: tests/tcg/i386/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                               ^

ERROR: space required before that '&' (ctx:OxV)
#693: FILE: tests/tcg/i386/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                                ^

ERROR: suspect code indent for conditional statements (4, 6)
#694: FILE: tests/tcg/i386/litmus/affinity.c:105:
+    if (r != 0) {
+      errexit("pthread_setaffinity_np",r) ;

ERROR: space required after that ',' (ctx:VxV)
#695: FILE: tests/tcg/i386/litmus/affinity.c:106:
+      errexit("pthread_setaffinity_np",r) ;
                                       ^

ERROR: open brace '{' following function declarations go on the next line
#701: FILE: tests/tcg/i386/litmus/affinity.c:112:
+void write_one_affinity(int a) {

ERROR: space required after that ',' (ctx:VxO)
#705: FILE: tests/tcg/i386/litmus/affinity.c:116:
+    CPU_SET(a,&mask) ;
              ^

ERROR: space required before that '&' (ctx:OxV)
#705: FILE: tests/tcg/i386/litmus/affinity.c:116:
+    CPU_SET(a,&mask) ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#707: FILE: tests/tcg/i386/litmus/affinity.c:118:
+    if (r != 0) {
+      errexit("pthread_setaffinity_np",r) ;

ERROR: space required after that ',' (ctx:VxV)
#708: FILE: tests/tcg/i386/litmus/affinity.c:119:
+      errexit("pthread_setaffinity_np",r) ;
                                       ^

ERROR: open brace '{' following function declarations go on the next line
#718: FILE: tests/tcg/i386/litmus/affinity.c:129:
+static int get_present(void) {

ERROR: space required after that ',' (ctx:VxV)
#719: FILE: tests/tcg/i386/litmus/affinity.c:130:
+  FILE *fp = fopen(present,"r") ;
                           ^

ERROR: trailing statements should be on next line
#720: FILE: tests/tcg/i386/litmus/affinity.c:131:
+  if (fp == NULL) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#720: FILE: tests/tcg/i386/litmus/affinity.c:131:
+  if (fp == NULL) return -1 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#721: FILE: tests/tcg/i386/litmus/affinity.c:132:
+  int r1,r2 ;
         ^

ERROR: space required after that ',' (ctx:VxV)
#722: FILE: tests/tcg/i386/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                    ^

ERROR: space required after that ',' (ctx:VxO)
#722: FILE: tests/tcg/i386/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                              ^

ERROR: space required before that '&' (ctx:OxV)
#722: FILE: tests/tcg/i386/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                               ^

ERROR: space required after that ',' (ctx:VxO)
#722: FILE: tests/tcg/i386/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                                  ^

ERROR: space required before that '&' (ctx:OxV)
#722: FILE: tests/tcg/i386/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                                   ^

ERROR: trailing statements should be on next line
#724: FILE: tests/tcg/i386/litmus/affinity.c:135:
+  if (n != 2) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#724: FILE: tests/tcg/i386/litmus/affinity.c:135:
+  if (n != 2) return -1 ;
[...]

ERROR: spaces required around that '-' (ctx:VxV)
#725: FILE: tests/tcg/i386/litmus/affinity.c:136:
+  return r2-r1+1 ;
            ^

ERROR: spaces required around that '+' (ctx:VxV)
#725: FILE: tests/tcg/i386/litmus/affinity.c:136:
+  return r2-r1+1 ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#728: FILE: tests/tcg/i386/litmus/affinity.c:139:
+void force_one_affinity(int a, int sz,int verbose, char *name) {

ERROR: space required after that ',' (ctx:VxV)
#728: FILE: tests/tcg/i386/litmus/affinity.c:139:
+void force_one_affinity(int a, int sz,int verbose, char *name) {
                                      ^

ERROR: space required after that ',' (ctx:VxO)
#733: FILE: tests/tcg/i386/litmus/affinity.c:144:
+    CPU_SET(a,&mask) ;
              ^

ERROR: space required before that '&' (ctx:OxV)
#733: FILE: tests/tcg/i386/litmus/affinity.c:144:
+    CPU_SET(a,&mask) ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#734: FILE: tests/tcg/i386/litmus/affinity.c:145:
+    do {
+      r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;

ERROR: suspect code indent for conditional statements (8, 10)
#737: FILE: tests/tcg/i386/litmus/affinity.c:148:
+        if (verbose)
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;

ERROR: braces {} are necessary for all arms of this statement
#737: FILE: tests/tcg/i386/litmus/affinity.c:148:
+        if (verbose)
[...]

ERROR: space required after that ',' (ctx:VxV)
#738: FILE: tests/tcg/i386/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#738: FILE: tests/tcg/i386/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                                                 ^

ERROR: space required after that ',' (ctx:VxV)
#738: FILE: tests/tcg/i386/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                                                      ^

ERROR: suspect code indent for conditional statements (8, 10)
#740: FILE: tests/tcg/i386/litmus/affinity.c:151:
+        if (verbose > 1)
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;

ERROR: braces {} are necessary for all arms of this statement
#740: FILE: tests/tcg/i386/litmus/affinity.c:151:
+        if (verbose > 1)
[...]

ERROR: space required after that ',' (ctx:VxV)
#741: FILE: tests/tcg/i386/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#741: FILE: tests/tcg/i386/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#741: FILE: tests/tcg/i386/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                                                 ^

ERROR: spaces required around that '+' (ctx:VxV)
#742: FILE: tests/tcg/i386/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;
                                  ^

ERROR: trailing statements should be on next line
#742: FILE: tests/tcg/i386/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;

ERROR: braces {} are necessary for all arms of this statement
#742: FILE: tests/tcg/i386/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#743: FILE: tests/tcg/i386/litmus/affinity.c:154:
+        warm_up(nwarm,sec/100) ;
                      ^

ERROR: spaces required around that '/' (ctx:VxV)
#743: FILE: tests/tcg/i386/litmus/affinity.c:154:
+        warm_up(nwarm,sec/100) ;
                          ^

ERROR: line over 90 characters
#796: FILE: tests/tcg/i386/litmus/comp.sh:2:
+GCCOPTS="-D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -fomit-frame-pointer 
-O2 -pthread"

ERROR: open brace '{' following function declarations go on the next line
#849: FILE: tests/tcg/i386/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: storage class should be at the beginning of the declaration
#849: FILE: tests/tcg/i386/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: inline keyword should sit between storage class and type
#849: FILE: tests/tcg/i386/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: open brace '{' following function declarations go on the next line
#859: FILE: tests/tcg/i386/litmus/litmus_rand.c:49:
+int rand_bit(st_t *st)  {

ERROR: trailing whitespace
#862: FILE: tests/tcg/i386/litmus/litmus_rand.c:52:
+  return r ; $

ERROR: space prohibited between function name and open parenthesis '('
#867: FILE: tests/tcg/i386/litmus/litmus_rand.c:57:
+uint32_t rand_k (uint32_t *st,uint32_t k) {

ERROR: space required after that ',' (ctx:VxV)
#867: FILE: tests/tcg/i386/litmus/litmus_rand.c:57:
+uint32_t rand_k (uint32_t *st,uint32_t k) {
                              ^

ERROR: spaces required around that '-' (ctx:VxV)
#872: FILE: tests/tcg/i386/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
             ^

ERROR: spaces required around that '-' (ctx:VxV)
#872: FILE: tests/tcg/i386/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
                       ^

ERROR: spaces required around that '+' (ctx:VxV)
#872: FILE: tests/tcg/i386/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#907: FILE: tests/tcg/i386/litmus/litmus_rand.h:27:
+uint32_t rand_k(st_t *st,uint32_t n) ;
                         ^

ERROR: if this code is redundant consider removing it
#939: FILE: tests/tcg/i386/litmus/outs.c:24:
+#if 0

ERROR: open brace '{' following function declarations go on the next line
#940: FILE: tests/tcg/i386/litmus/outs.c:25:
+static void debug(int *t, int i, int j) {

ERROR: spaces required around that '=' (ctx:VxV)
#941: FILE: tests/tcg/i386/litmus/outs.c:26:
+  for (int k=i ; k <= j ; k++)
             ^

ERROR: braces {} are necessary even for single statement blocks
#941: FILE: tests/tcg/i386/litmus/outs.c:26:
+  for (int k=i ; k <= j ; k++)
+    fprintf(stderr,"%i",t[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#942: FILE: tests/tcg/i386/litmus/outs.c:27:
+    fprintf(stderr,"%i",t[k]) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#942: FILE: tests/tcg/i386/litmus/outs.c:27:
+    fprintf(stderr,"%i",t[k]) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#943: FILE: tests/tcg/i386/litmus/outs.c:28:
+  fprintf(stderr,"\n") ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#950: FILE: tests/tcg/i386/litmus/outs.c:35:
+static outs_t *alloc_outs(intmax_t k) {

ERROR: open brace '{' following function declarations go on the next line
#959: FILE: tests/tcg/i386/litmus/outs.c:44:
+void free_outs(outs_t *p) {

ERROR: trailing statements should be on next line
#960: FILE: tests/tcg/i386/litmus/outs.c:45:
+  if (p == NULL) return ;

ERROR: braces {} are necessary for all arms of this statement
#960: FILE: tests/tcg/i386/litmus/outs.c:45:
+  if (p == NULL) return ;
[...]

WARNING: line over 80 characters
#967: FILE: tests/tcg/i386/litmus/outs.c:52:
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, 
int show) {

ERROR: open brace '{' following function declarations go on the next line
#967: FILE: tests/tcg/i386/litmus/outs.c:52:
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, 
int show) {

ERROR: suspect code indent for conditional statements (4, 6)
#976: FILE: tests/tcg/i386/litmus/outs.c:61:
+    if (k[i] > p->k) {
+      q = &(p->next) ;

ERROR: suspect code indent for conditional statements (4, 6)
#979: FILE: tests/tcg/i386/litmus/outs.c:64:
+    } else if (i <= 0) {
+      p->c += c ;

ERROR: suspect code indent for conditional statements (4, 6)
#988: FILE: tests/tcg/i386/litmus/outs.c:73:
+    if (p == NULL || k[i] < p->k) {
+      outs_t *a = alloc_outs(k[i]) ;

ERROR: open brace '{' following function declarations go on the next line
#997: FILE: tests/tcg/i386/litmus/outs.c:82:
+outs_t *add_outcome_outs(outs_t *p, intmax_t *k, int sz, count_t c, int show) {

ERROR: space required after that ',' (ctx:VxV)
#998: FILE: tests/tcg/i386/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#998: FILE: tests/tcg/i386/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                   ^

ERROR: spaces required around that '-' (ctx:VxV)
#998: FILE: tests/tcg/i386/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#998: FILE: tests/tcg/i386/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#998: FILE: tests/tcg/i386/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#1001: FILE: tests/tcg/i386/litmus/outs.c:86:
+count_t sum_outs(outs_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#1010: FILE: tests/tcg/i386/litmus/outs.c:95:
+int finals_outs(outs_t *p) {

ERROR: trailing statements should be on next line
#1013: FILE: tests/tcg/i386/litmus/outs.c:98:
+    if (p->c > 0) r++ ;

ERROR: braces {} are necessary for all arms of this statement
#1013: FILE: tests/tcg/i386/litmus/outs.c:98:
+    if (p->c > 0) r++ ;
[...]

WARNING: line over 80 characters
#1019: FILE: tests/tcg/i386/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {

ERROR: space prohibited between function name and open parenthesis '('
#1019: FILE: tests/tcg/i386/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {

ERROR: space required after that ',' (ctx:VxV)
#1019: FILE: tests/tcg/i386/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1019: FILE: tests/tcg/i386/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {
                                                                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#1021: FILE: tests/tcg/i386/litmus/outs.c:106:
+    buff[sz-1] = p->k ;
            ^

ERROR: suspect code indent for conditional statements (4, 6)
#1022: FILE: tests/tcg/i386/litmus/outs.c:107:
+    if (p->c > 0) {
+      dout(chan,buff,p->c,p->show) ;

ERROR: space required after that ',' (ctx:VxV)
#1023: FILE: tests/tcg/i386/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#1023: FILE: tests/tcg/i386/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1023: FILE: tests/tcg/i386/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                          ^

ERROR: suspect code indent for conditional statements (4, 6)
#1024: FILE: tests/tcg/i386/litmus/outs.c:109:
+    } else if (p->down) {
+      dump_outs(chan,dout,p->down,buff,sz-1) ;

ERROR: space required after that ',' (ctx:VxV)
#1025: FILE: tests/tcg/i386/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1025: FILE: tests/tcg/i386/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1025: FILE: tests/tcg/i386/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1025: FILE: tests/tcg/i386/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                       ^

ERROR: spaces required around that '-' (ctx:VxV)
#1025: FILE: tests/tcg/i386/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#1031: FILE: tests/tcg/i386/litmus/outs.c:116:
+static outs_t *do_merge_outs(outs_t *p, outs_t *q) {

ERROR: do not use C99 // comments
#1032: FILE: tests/tcg/i386/litmus/outs.c:117:
+  if (q == NULL) { // Nothing to add

ERROR: trailing statements should be on next line
#1032: FILE: tests/tcg/i386/litmus/outs.c:117:
+  if (q == NULL) { // Nothing to add

ERROR: do not use C99 // comments
#1035: FILE: tests/tcg/i386/litmus/outs.c:120:
+  if (p == NULL || q->k < p->k) { // Need a cell

ERROR: trailing statements should be on next line
#1035: FILE: tests/tcg/i386/litmus/outs.c:120:
+  if (p == NULL || q->k < p->k) { // Need a cell

ERROR: space required after that ',' (ctx:VxV)
#1043: FILE: tests/tcg/i386/litmus/outs.c:128:
+    p->down = do_merge_outs(p->down,q->down) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1044: FILE: tests/tcg/i386/litmus/outs.c:129:
+    p->next = do_merge_outs(p->next,q->next) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1046: FILE: tests/tcg/i386/litmus/outs.c:131:
+    p->next = do_merge_outs(p->next,q) ;
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#1051: FILE: tests/tcg/i386/litmus/outs.c:136:
+outs_t *merge_outs(outs_t *p, outs_t *q, int sz) {

ERROR: space required after that ',' (ctx:VxV)
#1052: FILE: tests/tcg/i386/litmus/outs.c:137:
+  return do_merge_outs(p,q) ;
                         ^

ERROR: open brace '{' following function declarations go on the next line
#1055: FILE: tests/tcg/i386/litmus/outs.c:140:
+int same_outs(outs_t *p,outs_t *q) {

ERROR: space required after that ',' (ctx:VxV)
#1055: FILE: tests/tcg/i386/litmus/outs.c:140:
+int same_outs(outs_t *p,outs_t *q) {
                        ^

ERROR: trailing statements should be on next line
#1057: FILE: tests/tcg/i386/litmus/outs.c:142:
+    if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#1057: FILE: tests/tcg/i386/litmus/outs.c:142:
+    if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1058: FILE: tests/tcg/i386/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;
                           ^

ERROR: trailing statements should be on next line
#1058: FILE: tests/tcg/i386/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#1058: FILE: tests/tcg/i386/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxO)
#1104: FILE: tests/tcg/i386/litmus/outs.h:35:
+  struct outs_t *next,*down ;
                      ^

ERROR: space required before that '*' (ctx:OxV)
#1104: FILE: tests/tcg/i386/litmus/outs.h:35:
+  struct outs_t *next,*down ;
                       ^

WARNING: line over 80 characters
#1115: FILE: tests/tcg/i386/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;

ERROR: space prohibited between function name and open parenthesis '('
#1115: FILE: tests/tcg/i386/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;

ERROR: space required after that ',' (ctx:VxV)
#1115: FILE: tests/tcg/i386/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1116: FILE: tests/tcg/i386/litmus/outs.h:47:
+outs_t *merge_outs(outs_t *p,outs_t *q, int sz) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#1117: FILE: tests/tcg/i386/litmus/outs.h:48:
+int same_outs(outs_t *p,outs_t *q) ;
                        ^

ERROR: line over 90 characters
#1158: FILE: tests/tcg/i386/litmus/run.sh:34:
+Command line: ../litmus-7.22/litmus -exit true -mach 
../alex_litmus/overdrive01 -o run.x86 x86.tests/SAL.litmus

ERROR: line over 90 characters
#1165: FILE: tests/tcg/i386/litmus/run.sh:41:
+/* gcc options: -D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 
-fomit-frame-pointer -O2 -pthread */

ERROR: open brace '{' following function declarations go on the next line
#1225: FILE: tests/tcg/i386/litmus/utils.c:32:
+static void checkerrlog(void) {

ERROR: trailing statements should be on next line
#1226: FILE: tests/tcg/i386/litmus/utils.c:33:
+  if (!errlog) errlog = stderr ;

ERROR: braces {} are necessary for all arms of this statement
#1226: FILE: tests/tcg/i386/litmus/utils.c:33:
+  if (!errlog) errlog = stderr ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1229: FILE: tests/tcg/i386/litmus/utils.c:36:
+void seterrlog(FILE *chan) {

ERROR: open brace '{' following function declarations go on the next line
#1233: FILE: tests/tcg/i386/litmus/utils.c:40:
+int log_error(const char *fmt, ...) {

ERROR: open brace '{' following function declarations go on the next line
#1244: FILE: tests/tcg/i386/litmus/utils.c:51:
+void fatal(char *msg) {

ERROR: space required after that ',' (ctx:VxV)
#1247: FILE: tests/tcg/i386/litmus/utils.c:54:
+  fprintf(stdout,"Failure: %s\n", msg) ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#1251: FILE: tests/tcg/i386/litmus/utils.c:58:
+void errexit(char *msg,int err) {

ERROR: space required after that ',' (ctx:VxV)
#1251: FILE: tests/tcg/i386/litmus/utils.c:58:
+void errexit(char *msg,int err) {
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1252: FILE: tests/tcg/i386/litmus/utils.c:59:
+  log_error("%s: %s\n",msg,strerror(err)) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1252: FILE: tests/tcg/i386/litmus/utils.c:59:
+  log_error("%s: %s\n",msg,strerror(err)) ;
                           ^

ERROR: open brace '{' following function declarations go on the next line
#1257: FILE: tests/tcg/i386/litmus/utils.c:64:
+void *malloc_check(size_t sz) {

ERROR: trailing statements should be on next line
#1258: FILE: tests/tcg/i386/litmus/utils.c:65:
+  if (sz == 0) return NULL ;

ERROR: braces {} are necessary for all arms of this statement
#1258: FILE: tests/tcg/i386/litmus/utils.c:65:
+  if (sz == 0) return NULL ;
[...]

ERROR: trailing statements should be on next line
#1261: FILE: tests/tcg/i386/litmus/utils.c:68:
+    if (!errno) errno = ENOMEM ;

ERROR: braces {} are necessary for all arms of this statement
#1261: FILE: tests/tcg/i386/litmus/utils.c:68:
+    if (!errno) errno = ENOMEM ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1262: FILE: tests/tcg/i386/litmus/utils.c:69:
+    errexit("malloc",errno) ;
                     ^

ERROR: open brace '{' following function declarations go on the next line
#1269: FILE: tests/tcg/i386/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {

ERROR: space required after that ',' (ctx:VxV)
#1269: FILE: tests/tcg/i386/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {
                      ^

ERROR: space required after that ',' (ctx:VxV)
#1269: FILE: tests/tcg/i386/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#1271: FILE: tests/tcg/i386/litmus/utils.c:78:
+    fprintf(fp,"%i",p[0]) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#1271: FILE: tests/tcg/i386/litmus/utils.c:78:
+    fprintf(fp,"%i",p[0]) ;
                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#1272: FILE: tests/tcg/i386/litmus/utils.c:79:
+    for (int k = 1 ; k < n ; k++) {
+      fprintf(fp,",%i",p[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#1273: FILE: tests/tcg/i386/litmus/utils.c:80:
+      fprintf(fp,",%i",p[k]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#1273: FILE: tests/tcg/i386/litmus/utils.c:80:
+      fprintf(fp,",%i",p[k]) ;
                       ^

ERROR: open brace '{' following function declarations go on the next line
#1279: FILE: tests/tcg/i386/litmus/utils.c:86:
+void *do_align(void *p,size_t sz) {

ERROR: space required after that ',' (ctx:VxV)
#1279: FILE: tests/tcg/i386/litmus/utils.c:86:
+void *do_align(void *p,size_t sz) {
                       ^

ERROR: spaces required around that '-' (ctx:VxV)
#1281: FILE: tests/tcg/i386/litmus/utils.c:88:
+  x += sz-1 ;
          ^

ERROR: open brace '{' following function declarations go on the next line
#1287: FILE: tests/tcg/i386/litmus/utils.c:94:
+void *do_noalign(void *p,size_t sz) {

ERROR: space required after that ',' (ctx:VxV)
#1287: FILE: tests/tcg/i386/litmus/utils.c:94:
+void *do_noalign(void *p,size_t sz) {
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1288: FILE: tests/tcg/i386/litmus/utils.c:95:
+  void *q = do_align(p,sz) ;
                       ^

ERROR: spaces required around that '/' (ctx:VxV)
#1289: FILE: tests/tcg/i386/litmus/utils.c:96:
+  void *r = q - sz/2 ;
                   ^

ERROR: spaces required around that '/' (ctx:VxV)
#1290: FILE: tests/tcg/i386/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;
                        ^

ERROR: trailing statements should be on next line
#1290: FILE: tests/tcg/i386/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;

ERROR: braces {} are necessary for all arms of this statement
#1290: FILE: tests/tcg/i386/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1294: FILE: tests/tcg/i386/litmus/utils.c:101:
+void cat_file(char *path, char *msg, FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#1295: FILE: tests/tcg/i386/litmus/utils.c:102:
+  FILE *fp = fopen(path,"r") ;
                        ^

ERROR: trailing statements should be on next line
#1296: FILE: tests/tcg/i386/litmus/utils.c:103:
+  if (fp == NULL) return ;

ERROR: braces {} are necessary for all arms of this statement
#1296: FILE: tests/tcg/i386/litmus/utils.c:103:
+  if (fp == NULL) return ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1297: FILE: tests/tcg/i386/litmus/utils.c:104:
+  fprintf(out,"%s\n",msg) ;
              ^

ERROR: space required after that ',' (ctx:VxV)
#1297: FILE: tests/tcg/i386/litmus/utils.c:104:
+  fprintf(out,"%s\n",msg) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1298: FILE: tests/tcg/i386/litmus/utils.c:105:
+  int c,nl=1 ;
        ^

ERROR: spaces required around that '=' (ctx:VxV)
#1298: FILE: tests/tcg/i386/litmus/utils.c:105:
+  int c,nl=1 ;
           ^

ERROR: space required after that ',' (ctx:VxV)
#1300: FILE: tests/tcg/i386/litmus/utils.c:107:
+    fputc(c,out) ;
            ^

ERROR: space required after that ',' (ctx:VxV)
#1304: FILE: tests/tcg/i386/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;
                      ^

ERROR: trailing statements should be on next line
#1304: FILE: tests/tcg/i386/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;

ERROR: braces {} are necessary for all arms of this statement
#1304: FILE: tests/tcg/i386/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1311: FILE: tests/tcg/i386/litmus/utils.c:118:
+cpus_t *cpus_create(int sz) {

ERROR: spaces required around that '*' (ctx:VxV)
#1314: FILE: tests/tcg/i386/litmus/utils.c:121:
+  r->cpu = malloc_check(sizeof(r->cpu[0])*sz)  ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#1318: FILE: tests/tcg/i386/litmus/utils.c:125:
+cpus_t *cpus_create_init(int sz, int t[]) {

ERROR: trailing statements should be on next line
#1320: FILE: tests/tcg/i386/litmus/utils.c:127:
+  for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;

ERROR: braces {} are necessary even for single statement blocks
#1320: FILE: tests/tcg/i386/litmus/utils.c:127:
+  for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;

ERROR: open brace '{' following function declarations go on the next line
#1324: FILE: tests/tcg/i386/litmus/utils.c:131:
+void cpus_free(cpus_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#1329: FILE: tests/tcg/i386/litmus/utils.c:136:
+void cpus_dump(FILE *fp, cpus_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#1330: FILE: tests/tcg/i386/litmus/utils.c:137:
+  pp_ints(fp,p->cpu,p->sz) ;
             ^

ERROR: space required after that ',' (ctx:VxV)
#1330: FILE: tests/tcg/i386/litmus/utils.c:137:
+  pp_ints(fp,p->cpu,p->sz) ;
                    ^

ERROR: open brace '{' following function declarations go on the next line
#1333: FILE: tests/tcg/i386/litmus/utils.c:140:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {

ERROR: space required after that ',' (ctx:VxV)
#1333: FILE: tests/tcg/i386/litmus/utils.c:140:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1335: FILE: tests/tcg/i386/litmus/utils.c:142:
+    fprintf(fp,"[") ;
               ^

ERROR: space required after that ',' (ctx:VxO)
#1336: FILE: tests/tcg/i386/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
               ^

ERROR: space required before that '&' (ctx:OxV)
#1336: FILE: tests/tcg/i386/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#1336: FILE: tests/tcg/i386/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1337: FILE: tests/tcg/i386/litmus/utils.c:144:
+    fprintf(fp,"] {") ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#1338: FILE: tests/tcg/i386/litmus/utils.c:145:
+    if (nprocs > 0) {
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;

ERROR: space required after that ',' (ctx:VxV)
#1339: FILE: tests/tcg/i386/litmus/utils.c:146:
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#1339: FILE: tests/tcg/i386/litmus/utils.c:146:
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;
                      ^

ERROR: space required after that ',' (ctx:VxV)
#1341: FILE: tests/tcg/i386/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#1341: FILE: tests/tcg/i386/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                         ^

ERROR: spaces required around that '+' (ctx:VxV)
#1341: FILE: tests/tcg/i386/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1344: FILE: tests/tcg/i386/litmus/utils.c:151:
+    fprintf(fp,"}\n") ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#1353: FILE: tests/tcg/i386/litmus/utils.c:160:
+void ints_dump(FILE *fp, ints_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#1355: FILE: tests/tcg/i386/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#1355: FILE: tests/tcg/i386/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1355: FILE: tests/tcg/i386/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
                         ^

ERROR: suspect code indent for conditional statements (4, 6)
#1356: FILE: tests/tcg/i386/litmus/utils.c:163:
+    for (int k = 1 ; k < p->sz ; k++) {
+      fprintf(fp,",%i:%i",k,p->t[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#1357: FILE: tests/tcg/i386/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#1357: FILE: tests/tcg/i386/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1357: FILE: tests/tcg/i386/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                            ^

ERROR: open brace '{' following function declarations go on the next line
#1365: FILE: tests/tcg/i386/litmus/utils.c:172:
+void prefetch_dump(FILE *fp, prfdirs_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#1371: FILE: tests/tcg/i386/litmus/utils.c:178:
+    for (int _v = 0 ; _v < nvars ; _v++) {
+      prfdir_t dir = r[_v].dir ;

ERROR: trailing statements should be on next line
#1375: FILE: tests/tcg/i386/litmus/utils.c:182:
+        if (dir == flush) c = 'F' ;

ERROR: braces {} are necessary for all arms of this statement
#1375: FILE: tests/tcg/i386/litmus/utils.c:182:
+        if (dir == flush) c = 'F' ;
[...]
+        else if (dir == touch) c = 'T' ;
[...]
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: trailing statements should be on next line
#1376: FILE: tests/tcg/i386/litmus/utils.c:183:
+        else if (dir == touch) c = 'T' ;

ERROR: braces {} are necessary for all arms of this statement
#1376: FILE: tests/tcg/i386/litmus/utils.c:183:
+        else if (dir == touch) c = 'T' ;
[...]
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: trailing statements should be on next line
#1377: FILE: tests/tcg/i386/litmus/utils.c:184:
+        else if (dir == touch_store) c = 'W' ;

ERROR: braces {} are necessary for all arms of this statement
#1377: FILE: tests/tcg/i386/litmus/utils.c:184:
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: suspect code indent for conditional statements (8, 10)
#1378: FILE: tests/tcg/i386/litmus/utils.c:185:
+        if (some) {
+          fprintf(fp,",") ;

ERROR: space required after that ',' (ctx:VxV)
#1379: FILE: tests/tcg/i386/litmus/utils.c:186:
+          fprintf(fp,",") ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1383: FILE: tests/tcg/i386/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#1383: FILE: tests/tcg/i386/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1383: FILE: tests/tcg/i386/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1383: FILE: tests/tcg/i386/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                                            ^

ERROR: open brace '{' following function declarations go on the next line
#1389: FILE: tests/tcg/i386/litmus/utils.c:196:
+static void set_prefetch(prfdirs_t *p, prfdir_t d) {

ERROR: suspect code indent for conditional statements (4, 6)
#1394: FILE: tests/tcg/i386/litmus/utils.c:201:
+    for (int _v = 0 ; _v < nvars ; _v++) {
+      r[_v].dir = d ;

ERROR: open brace '{' following function declarations go on the next line
#1402: FILE: tests/tcg/i386/litmus/utils.c:209:
+int gcd(int a, int b) {

ERROR: trailing statements should be on next line
#1404: FILE: tests/tcg/i386/litmus/utils.c:211:
+    if (a == 0) return b ;

ERROR: braces {} are necessary for all arms of this statement
#1404: FILE: tests/tcg/i386/litmus/utils.c:211:
+    if (a == 0) return b ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1414: FILE: tests/tcg/i386/litmus/utils.c:221:
+cpus_t *coremap_seq(int navail, int nways) {

ERROR: suspect code indent for conditional statements (4, 6)
#1419: FILE: tests/tcg/i386/litmus/utils.c:226:
+    for (int k = 0 ; k < nways ; k++) {
+      r->cpu[i++] = c ;

ERROR: open brace '{' following function declarations go on the next line
#1426: FILE: tests/tcg/i386/litmus/utils.c:233:
+cpus_t *coremap_end(int navail, int nways) {

ERROR: suspect code indent for conditional statements (4, 6)
#1431: FILE: tests/tcg/i386/litmus/utils.c:238:
+    for (int c = 0 ; c < ncores ; c++) {
+      r->cpu[i++] = c ;

ERROR: open brace '{' following function declarations go on the next line
#1444: FILE: tests/tcg/i386/litmus/utils.c:251:
+static void mapcore_free(mapcore_t *p) {

ERROR: trailing statements should be on next line
#1445: FILE: tests/tcg/i386/litmus/utils.c:252:
+  for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;

ERROR: braces {} are necessary even for single statement blocks
#1445: FILE: tests/tcg/i386/litmus/utils.c:252:
+  for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;

ERROR: if this code is redundant consider removing it
#1450: FILE: tests/tcg/i386/litmus/utils.c:257:
+#if 0

ERROR: open brace '{' following function declarations go on the next line
#1451: FILE: tests/tcg/i386/litmus/utils.c:258:
+static mapcore_t *inverse_coremap(cpus_t *p, int nways) {

ERROR: open brace '{' following function declarations go on the next line
#1468: FILE: tests/tcg/i386/litmus/utils.c:275:
+static int get_ncores(cpus_t *cm) {

ERROR: trailing statements should be on next line
#1471: FILE: tests/tcg/i386/litmus/utils.c:278:
+    if (cm->cpu[k] > r) r = cm->cpu[k] ;

ERROR: braces {} are necessary for all arms of this statement
#1471: FILE: tests/tcg/i386/litmus/utils.c:278:
+    if (cm->cpu[k] > r) r = cm->cpu[k] ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#1473: FILE: tests/tcg/i386/litmus/utils.c:280:
+  return r+1 ;
           ^

ERROR: open brace '{' following function declarations go on the next line
#1476: FILE: tests/tcg/i386/litmus/utils.c:283:
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {

ERROR: space required after that ',' (ctx:VxV)
#1476: FILE: tests/tcg/i386/litmus/utils.c:283:
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {
                                             ^

ERROR: trailing statements should be on next line
#1480: FILE: tests/tcg/i386/litmus/utils.c:287:
+    if (cm->cpu[p->cpu[k]] == c) sz++ ;

ERROR: braces {} are necessary for all arms of this statement
#1480: FILE: tests/tcg/i386/litmus/utils.c:287:
+    if (cm->cpu[p->cpu[k]] == c) sz++ ;
[...]

ERROR: trailing statements should be on next line
#1486: FILE: tests/tcg/i386/litmus/utils.c:293:
+    if (cm->cpu[proc] == c) r->cpu[i++] = proc ;

ERROR: braces {} are necessary for all arms of this statement
#1486: FILE: tests/tcg/i386/litmus/utils.c:293:
+    if (cm->cpu[proc] == c) r->cpu[i++] = proc ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1491: FILE: tests/tcg/i386/litmus/utils.c:298:
+static  mapcore_t *inverse_procs(cpus_t *cm, cpus_t *p) {

ERROR: spaces required around that '*' (ctx:VxV)
#1495: FILE: tests/tcg/i386/litmus/utils.c:302:
+  r->core = malloc_check(sizeof(r->core[0])*ncores) ;
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1497: FILE: tests/tcg/i386/litmus/utils.c:304:
+    r->core[c] = get_core_procs(cm,p,c) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1497: FILE: tests/tcg/i386/litmus/utils.c:304:
+    r->core[c] = get_core_procs(cm,p,c) ;
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1502: FILE: tests/tcg/i386/litmus/utils.c:309:
+static int get_node_sz(int *p) {

ERROR: trailing statements should be on next line
#1504: FILE: tests/tcg/i386/litmus/utils.c:311:
+  while (*p++ >= 0) r++ ;

ERROR: braces {} are necessary even for single statement blocks
#1504: FILE: tests/tcg/i386/litmus/utils.c:311:
+  while (*p++ >= 0) r++ ;

ERROR: open brace '{' following function declarations go on the next line
#1508: FILE: tests/tcg/i386/litmus/utils.c:315:
+static int get_n(int **p) {

ERROR: open brace '{' following function declarations go on the next line
#1517: FILE: tests/tcg/i386/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {

ERROR: space required after that ',' (ctx:VxV)
#1517: FILE: tests/tcg/i386/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1517: FILE: tests/tcg/i386/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1517: FILE: tests/tcg/i386/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                              ^

ERROR: suspect code indent for conditional statements (4, 6)
#1520: FILE: tests/tcg/i386/litmus/utils.c:327:
+    if (op >= 0) {
+      if (d[n*p+k]) {

ERROR: spaces required around that '*' (ctx:VxV)
#1521: FILE: tests/tcg/i386/litmus/utils.c:328:
+      if (d[n*p+k]) {
              ^

ERROR: spaces required around that '+' (ctx:VxV)
#1521: FILE: tests/tcg/i386/litmus/utils.c:328:
+      if (d[n*p+k]) {
                ^

ERROR: suspect code indent for conditional statements (8, 10)
#1523: FILE: tests/tcg/i386/litmus/utils.c:330:
+        if (oc == c) {
+          return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#1532: FILE: tests/tcg/i386/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {

ERROR: space required after that ',' (ctx:VxV)
#1532: FILE: tests/tcg/i386/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1532: FILE: tests/tcg/i386/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1532: FILE: tests/tcg/i386/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                             ^

ERROR: space required after that ',' (ctx:VxO)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                               ^

ERROR: space required before that '*' (ctx:OxV)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                                  ^

ERROR: trailing statements should be on next line
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#1534: FILE: tests/tcg/i386/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/i386/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
          ^

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/i386/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                   ^

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/i386/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/i386/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/i386/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1542: FILE: tests/tcg/i386/litmus/utils.c:349:
+  int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                           ^

ERROR: trailing statements should be on next line
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;

ERROR: braces {} are necessary for all arms of this statement
#1546: FILE: tests/tcg/i386/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
          ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                   ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1554: FILE: tests/tcg/i386/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1556: FILE: tests/tcg/i386/litmus/utils.c:363:
+  int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
                                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#1560: FILE: tests/tcg/i386/litmus/utils.c:367:
+    if (pk->sz > 0) {
+      if (found < 0) found = k ;

ERROR: trailing statements should be on next line
#1561: FILE: tests/tcg/i386/litmus/utils.c:368:
+      if (found < 0) found = k ;

ERROR: braces {} are necessary for all arms of this statement
#1561: FILE: tests/tcg/i386/litmus/utils.c:368:
+      if (found < 0) found = k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                                  ^

ERROR: trailing statements should be on next line
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;

ERROR: braces {} are necessary for all arms of this statement
#1562: FILE: tests/tcg/i386/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
[...]

ERROR: trailing statements should be on next line
#1566: FILE: tests/tcg/i386/litmus/utils.c:373:
+  if (found < 0) fatal("Cannot allocate threads") ;

ERROR: braces {} are necessary for all arms of this statement
#1566: FILE: tests/tcg/i386/litmus/utils.c:373:
+  if (found < 0) fatal("Cannot allocate threads") ;
[...]

ERROR: line over 90 characters
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {

ERROR: space prohibited between function name and open parenthesis '('
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {

ERROR: space required after that ',' (ctx:VxV)
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                                ^

ERROR: space required after that ',' (ctx:VxV)
#1570: FILE: tests/tcg/i386/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                                                
 ^

ERROR: space required after that ',' (ctx:VxV)
#1571: FILE: tests/tcg/i386/litmus/utils.c:378:
+  mapcore_t *mc = inverse_procs(cm,aff_cpus) ;
                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#1574: FILE: tests/tcg/i386/litmus/utils.c:381:
+  int d[n*n] ;
          ^

ERROR: spaces required around that '*' (ctx:VxV)
#1577: FILE: tests/tcg/i386/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;
                           ^

ERROR: trailing statements should be on next line
#1577: FILE: tests/tcg/i386/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;

ERROR: braces {} are necessary even for single statement blocks
#1577: FILE: tests/tcg/i386/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;

ERROR: suspect code indent for conditional statements (4, 6)
#1578: FILE: tests/tcg/i386/litmus/utils.c:385:
+    while (*q >= 0) {
+      int x = *q++, y = *q++ ;

ERROR: spaces required around that '*' (ctx:VxV)
#1580: FILE: tests/tcg/i386/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
          ^

ERROR: spaces required around that '+' (ctx:VxV)
#1580: FILE: tests/tcg/i386/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
            ^

ERROR: spaces required around that '*' (ctx:VxV)
#1580: FILE: tests/tcg/i386/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#1580: FILE: tests/tcg/i386/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
                       ^

ERROR: spaces required around that '*' (ctx:VxV)
#1584: FILE: tests/tcg/i386/litmus/utils.c:391:
+    int *a = &r[k*n] ;
                  ^

ERROR: trailing statements should be on next line
#1586: FILE: tests/tcg/i386/litmus/utils.c:393:
+    for (int i = 0 ; i < n ; i++) a[i] = -1 ;

ERROR: braces {} are necessary even for single statement blocks
#1586: FILE: tests/tcg/i386/litmus/utils.c:393:
+    for (int i = 0 ; i < n ; i++) a[i] = -1 ;

ERROR: suspect code indent for conditional statements (4, 6)
#1587: FILE: tests/tcg/i386/litmus/utils.c:394:
+    for (int **q = color ; *q ; q++) {
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                ^

ERROR: space required after that ',' (ctx:VxO)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                  ^

ERROR: space required before that '*' (ctx:OxV)
#1588: FILE: tests/tcg/i386/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                   ^

ERROR: suspect code indent for conditional statements (8, 10)
#1591: FILE: tests/tcg/i386/litmus/utils.c:398:
+        for (int *qq = *q ; *qq >= 0 ; qq++) {
+          p->sz-- ;

ERROR: suspect code indent for conditional statements (8, 10)
#1597: FILE: tests/tcg/i386/litmus/utils.c:404:
+        for (int *qq = *q ; *qq >= 0 ; qq++) {
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                ^

ERROR: space required after that ',' (ctx:VxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                  ^

ERROR: space required after that ',' (ctx:VxO)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                    ^

ERROR: space required before that '*' (ctx:OxV)
#1598: FILE: tests/tcg/i386/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1616: FILE: tests/tcg/i386/litmus/utils.c:423:
+static void usage(char *prog, cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#1617: FILE: tests/tcg/i386/litmus/utils.c:424:
+  log_error("usage: %s (options)*\n",prog) ;
                                     ^

ERROR: line over 90 characters
#1620: FILE: tests/tcg/i386/litmus/utils.c:427:
+  log_error("  -a <n>  run maximal number of tests for n available processors 
(default %i)\n",d->avail) ;

ERROR: space required after that ',' (ctx:VxV)
#1620: FILE: tests/tcg/i386/litmus/utils.c:427:
+  log_error("  -a <n>  run maximal number of tests for n available processors 
(default %i)\n",d->avail) ;
                                                                                
              ^

ERROR: space required after that ',' (ctx:VxV)
#1622: FILE: tests/tcg/i386/litmus/utils.c:429:
+  log_error("  -r <n>  perform n runs (default %i)\n",d->max_run) ;
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1624: FILE: tests/tcg/i386/litmus/utils.c:431:
+  log_error("  -s <n>  outcomes per run (default %i)\n",d->size_of_test) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1626: FILE: tests/tcg/i386/litmus/utils.c:433:
+    log_error("  -st <n> stride (default %i)\n",d->stride) ;
                                                ^

ERROR: line over 90 characters
#1631: FILE: tests/tcg/i386/litmus/utils.c:438:
+    log_error("  -i <n>  increment for allocating logical processors, -i 0 
disables affinity mode") ;

ERROR: suspect code indent for conditional statements (4, 6)
#1632: FILE: tests/tcg/i386/litmus/utils.c:439:
+    if (d->aff_mode == aff_incr) {
+      log_error(" (default %i)\n",d->aff_incr) ;

ERROR: space required after that ',' (ctx:VxV)
#1633: FILE: tests/tcg/i386/litmus/utils.c:440:
+      log_error(" (default %i)\n",d->aff_incr) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1638: FILE: tests/tcg/i386/litmus/utils.c:445:
+    cpus_dump(errlog,d->aff_cpus) ;
                     ^

ERROR: line over 90 characters
#1640: FILE: tests/tcg/i386/litmus/utils.c:447:
+    log_error("  +ra     randomise affinity%s\n",d->aff_mode == aff_random ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1640: FILE: tests/tcg/i386/litmus/utils.c:447:
+    log_error("  +ra     randomise affinity%s\n",d->aff_mode == aff_random ? " 
(default)" : "") ;
                                                 ^

ERROR: suspect code indent for conditional statements (4, 6)
#1641: FILE: tests/tcg/i386/litmus/utils.c:448:
+    if (d->aff_custom_enabled) {
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;

ERROR: line over 90 characters
#1642: FILE: tests/tcg/i386/litmus/utils.c:449:
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1642: FILE: tests/tcg/i386/litmus/utils.c:449:
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1646: FILE: tests/tcg/i386/litmus/utils.c:453:
+    if (d->aff_scan_enabled) {
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;

ERROR: line over 90 characters
#1647: FILE: tests/tcg/i386/litmus/utils.c:454:
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1647: FILE: tests/tcg/i386/litmus/utils.c:454:
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;
                                                         ^

WARNING: line over 80 characters
#1654: FILE: tests/tcg/i386/litmus/utils.c:461:
+    log_error("  +rm     randomise memory accesses%s\n",d->shuffle ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1654: FILE: tests/tcg/i386/litmus/utils.c:461:
+    log_error("  +rm     randomise memory accesses%s\n",d->shuffle ? " 
(default)" : "") ;
                                                        ^

ERROR: line over 90 characters
#1655: FILE: tests/tcg/i386/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxO)
#1655: FILE: tests/tcg/i386/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;
                                                               ^

ERROR: space required before that '!' (ctx:OxV)
#1655: FILE: tests/tcg/i386/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;
                                                                ^

ERROR: line over 90 characters
#1658: FILE: tests/tcg/i386/litmus/utils.c:465:
+    log_error("  +sc     stop as soon as possible%s\n",d->speedcheck ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1658: FILE: tests/tcg/i386/litmus/utils.c:465:
+    log_error("  +sc     stop as soon as possible%s\n",d->speedcheck ? " 
(default)" : "") ;
                                                       ^

WARNING: line over 80 characters
#1659: FILE: tests/tcg/i386/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;

ERROR: space required after that ',' (ctx:VxO)
#1659: FILE: tests/tcg/i386/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;
                                                 ^

ERROR: space required before that '!' (ctx:OxV)
#1659: FILE: tests/tcg/i386/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1666: FILE: tests/tcg/i386/litmus/utils.c:473:
+    ints_dump(errlog,d->delta_tb) ;
                     ^

ERROR: line over 90 characters
#1672: FILE: tests/tcg/i386/litmus/utils.c:479:
+    log_error("  +vb     show iteration timings%s\n",d->verbose_barrier ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#1672: FILE: tests/tcg/i386/litmus/utils.c:479:
+    log_error("  +vb     show iteration timings%s\n",d->verbose_barrier ? " 
(default)" : "") ;
                                                     ^

ERROR: line over 90 characters
#1673: FILE: tests/tcg/i386/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxO)
#1673: FILE: tests/tcg/i386/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
                                                            ^

ERROR: space required before that '!' (ctx:OxV)
#1673: FILE: tests/tcg/i386/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1678: FILE: tests/tcg/i386/litmus/utils.c:485:
+    prefetch_dump(errlog,d->prefetch) ;
                         ^

ERROR: line over 90 characters
#1683: FILE: tests/tcg/i386/litmus/utils.c:490:
+    log_error("  -prs <n> prefetch probability is 1/n, -prs 0 disables 
feature, default %i\n",d->static_prefetch) ;

ERROR: space required after that ',' (ctx:VxV)
#1683: FILE: tests/tcg/i386/litmus/utils.c:490:
+    log_error("  -prs <n> prefetch probability is 1/n, -prs 0 disables 
feature, default %i\n",d->static_prefetch) ;
                                                                                
              ^

ERROR: line over 90 characters
#1686: FILE: tests/tcg/i386/litmus/utils.c:493:
+    log_error("  -l <n>  measure time by running assembly in a loop of size 
<n> (default %i)\n",d->max_loop) ;

ERROR: space required after that ',' (ctx:VxV)
#1686: FILE: tests/tcg/i386/litmus/utils.c:493:
+    log_error("  -l <n>  measure time by running assembly in a loop of size 
<n> (default %i)\n",d->max_loop) ;
                                                                                
                ^

ERROR: space required after that ',' (ctx:VxV)
#1692: FILE: tests/tcg/i386/litmus/utils.c:499:
+    log_error("  -k <n>  undocumented (default %i)\n",d->sync_n) ;
                                                      ^

ERROR: space prohibited between function name and open parenthesis '('
#1697: FILE: tests/tcg/i386/litmus/utils.c:504:
+static long my_add (long x, long y) {

ERROR: spaces required around that '+' (ctx:VxV)
#1698: FILE: tests/tcg/i386/litmus/utils.c:505:
+  long r = x+y ;
             ^

ERROR: trailing statements should be on next line
#1699: FILE: tests/tcg/i386/litmus/utils.c:506:
+  if (r < x || r < y) { errno = ERANGE ; fatal("overflow") ; }

ERROR: open brace '{' following function declarations go on the next line
#1703: FILE: tests/tcg/i386/litmus/utils.c:510:
+static long my_pow10(int p,long x) {

ERROR: space required after that ',' (ctx:VxV)
#1703: FILE: tests/tcg/i386/litmus/utils.c:510:
+static long my_pow10(int p,long x) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1706: FILE: tests/tcg/i386/litmus/utils.c:513:
+    long y2 = my_add(r,r) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1707: FILE: tests/tcg/i386/litmus/utils.c:514:
+    long y4 = my_add(y2,y2) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#1708: FILE: tests/tcg/i386/litmus/utils.c:515:
+    long y8 = my_add(y4,y4) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#1709: FILE: tests/tcg/i386/litmus/utils.c:516:
+    r = my_add(y8,y2) ;
                  ^

ERROR: trailing statements should be on next line
#1711: FILE: tests/tcg/i386/litmus/utils.c:518:
+  if (r >= INT_MAX || r <= 0) {  errno = ERANGE ; fatal("overflow") ; }

ERROR: open brace '{' following function declarations go on the next line
#1715: FILE: tests/tcg/i386/litmus/utils.c:522:
+static int do_argint(char *p, char **q) {

ERROR: space required after that ',' (ctx:VxV)
#1716: FILE: tests/tcg/i386/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1716: FILE: tests/tcg/i386/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;
                       ^

ERROR: consider using qemu_strtol in preference to strtol
#1716: FILE: tests/tcg/i386/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;

ERROR: trailing statements should be on next line
#1717: FILE: tests/tcg/i386/litmus/utils.c:524:
+  if (errno == ERANGE) { fatal("overflow") ; }

ERROR: space required after that ',' (ctx:VxV)
#1718: FILE: tests/tcg/i386/litmus/utils.c:525:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }
                                                 ^

ERROR: trailing statements should be on next line
#1718: FILE: tests/tcg/i386/litmus/utils.c:525:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }

ERROR: space required after that ',' (ctx:VxV)
#1719: FILE: tests/tcg/i386/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }
                                                      ^

ERROR: spaces required around that '+=' (ctx:WxV)
#1719: FILE: tests/tcg/i386/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }
                                                               ^

ERROR: trailing statements should be on next line
#1719: FILE: tests/tcg/i386/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }

ERROR: else should follow close brace '}'
#1719: FILE: tests/tcg/i386/litmus/utils.c:526:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }

ERROR: open brace '{' following function declarations go on the next line
#1723: FILE: tests/tcg/i386/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#1723: FILE: tests/tcg/i386/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#1723: FILE: tests/tcg/i386/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {
                                     ^

ERROR: space required after that ',' (ctx:VxO)
#1725: FILE: tests/tcg/i386/litmus/utils.c:532:
+  long r = do_argint(p,&q) ;
                       ^

ERROR: space required before that '&' (ctx:OxV)
#1725: FILE: tests/tcg/i386/litmus/utils.c:532:
+  long r = do_argint(p,&q) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#1727: FILE: tests/tcg/i386/litmus/utils.c:534:
+    usage(prog,d) ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#1732: FILE: tests/tcg/i386/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#1732: FILE: tests/tcg/i386/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1732: FILE: tests/tcg/i386/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
                                           ^

ERROR: space required after that ',' (ctx:VxO)
#1739: FILE: tests/tcg/i386/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                          ^

ERROR: space required before that '&' (ctx:OxV)
#1739: FILE: tests/tcg/i386/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1739: FILE: tests/tcg/i386/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                             ^

ERROR: consider using qemu_strtol in preference to strtol
#1739: FILE: tests/tcg/i386/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;

ERROR: space required after that ',' (ctx:VxV)
#1740: FILE: tests/tcg/i386/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
                                                                      ^

ERROR: trailing statements should be on next line
#1740: FILE: tests/tcg/i386/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1740: FILE: tests/tcg/i386/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
[...]

ERROR: trailing statements should be on next line
#1742: FILE: tests/tcg/i386/litmus/utils.c:549:
+    if (*q == '\0') break ;

ERROR: braces {} are necessary for all arms of this statement
#1742: FILE: tests/tcg/i386/litmus/utils.c:549:
+    if (*q == '\0') break ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#1743: FILE: tests/tcg/i386/litmus/utils.c:550:
+    p = q+1 ;
          ^

ERROR: space required after that ',' (ctx:VxO)
#1749: FILE: tests/tcg/i386/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                              ^

ERROR: space required before that '&' (ctx:OxV)
#1749: FILE: tests/tcg/i386/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/i386/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                                 ^

ERROR: consider using qemu_strtol in preference to strtol
#1749: FILE: tests/tcg/i386/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;

ERROR: spaces required around that '+' (ctx:VxV)
#1750: FILE: tests/tcg/i386/litmus/utils.c:557:
+    p = q+1 ;
          ^

ERROR: open brace '{' following function declarations go on the next line
#1755: FILE: tests/tcg/i386/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#1755: FILE: tests/tcg/i386/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1755: FILE: tests/tcg/i386/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
                                                 ^

ERROR: space required after that ',' (ctx:VxO)
#1758: FILE: tests/tcg/i386/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                            ^

ERROR: space required before that '&' (ctx:OxV)
#1758: FILE: tests/tcg/i386/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#1758: FILE: tests/tcg/i386/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                               ^

ERROR: consider using qemu_strtol in preference to strtol
#1758: FILE: tests/tcg/i386/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;

ERROR: space required after that ',' (ctx:VxV)
#1759: FILE: tests/tcg/i386/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;
                                                                        ^

ERROR: trailing statements should be on next line
#1759: FILE: tests/tcg/i386/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1759: FILE: tests/tcg/i386/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#1760: FILE: tests/tcg/i386/litmus/utils.c:567:
+    p = q+1 ;
          ^

ERROR: space required after that ',' (ctx:VxO)
#1761: FILE: tests/tcg/i386/litmus/utils.c:568:
+    int v = do_argint(p,&q) ;
                        ^

ERROR: space required before that '&' (ctx:OxV)
#1761: FILE: tests/tcg/i386/litmus/utils.c:568:
+    int v = do_argint(p,&q) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1762: FILE: tests/tcg/i386/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
                                                             ^

ERROR: trailing statements should be on next line
#1762: FILE: tests/tcg/i386/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1762: FILE: tests/tcg/i386/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1764: FILE: tests/tcg/i386/litmus/utils.c:571:
+    if (*q == '\0') {
+      p = q ;

ERROR: spaces required around that '+' (ctx:VxV)
#1767: FILE: tests/tcg/i386/litmus/utils.c:574:
+      p = q+1 ;
            ^

ERROR: open brace '{' following function declarations go on the next line
#1772: FILE: tests/tcg/i386/litmus/utils.c:579:
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {

ERROR: space required after that ',' (ctx:VxV)
#1772: FILE: tests/tcg/i386/litmus/utils.c:579:
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1776: FILE: tests/tcg/i386/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
                    ^

ERROR: trailing statements should be on next line
#1776: FILE: tests/tcg/i386/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;

ERROR: braces {} are necessary for all arms of this statement
#1776: FILE: tests/tcg/i386/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1782: FILE: tests/tcg/i386/litmus/utils.c:589:
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#1782: FILE: tests/tcg/i386/litmus/utils.c:589:
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1795: FILE: tests/tcg/i386/litmus/utils.c:602:
+  set_prefetch(r,dir) ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#1798: FILE: tests/tcg/i386/litmus/utils.c:605:
+int parse_prefetch(char *p, prfdirs_t *r) {

ERROR: trailing statements should be on next line
#1799: FILE: tests/tcg/i386/litmus/utils.c:606:
+  if (!*p) return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#1799: FILE: tests/tcg/i386/litmus/utils.c:606:
+  if (!*p) return 1 ;
[...]

ERROR: space required after that ',' (ctx:VxO)
#1802: FILE: tests/tcg/i386/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1802: FILE: tests/tcg/i386/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1802: FILE: tests/tcg/i386/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                                ^

ERROR: consider using qemu_strtol in preference to strtol
#1802: FILE: tests/tcg/i386/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;

ERROR: suspect code indent for conditional statements (4, 6)
#1803: FILE: tests/tcg/i386/litmus/utils.c:610:
+    if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
+      return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#1803: FILE: tests/tcg/i386/litmus/utils.c:610:
+    if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#1805: FILE: tests/tcg/i386/litmus/utils.c:612:
+    p = q+1 ;
          ^

ERROR: suspect code indent for conditional statements (4, 6)
#1807: FILE: tests/tcg/i386/litmus/utils.c:614:
+    while (*p != '=') {
+      if (*p == '\0') return 0 ;

ERROR: trailing statements should be on next line
#1808: FILE: tests/tcg/i386/litmus/utils.c:615:
+      if (*p == '\0') return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#1808: FILE: tests/tcg/i386/litmus/utils.c:615:
+      if (*p == '\0') return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1812: FILE: tests/tcg/i386/litmus/utils.c:619:
+    prfone_t *loc_slot = get_name_slot(&r->t[proc],p0) ;
                                                   ^

ERROR: suspect code indent for conditional statements (4, 6)
#1813: FILE: tests/tcg/i386/litmus/utils.c:620:
+    if (loc_slot == NULL) {
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;

ERROR: space required after that ',' (ctx:VxV)
#1814: FILE: tests/tcg/i386/litmus/utils.c:621:
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1814: FILE: tests/tcg/i386/litmus/utils.c:621:
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;
                                                             ^

ERROR: trailing statements should be on next line
#1834: FILE: tests/tcg/i386/litmus/utils.c:641:
+    if (c == '\0') return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#1834: FILE: tests/tcg/i386/litmus/utils.c:641:
+    if (c == '\0') return 1 ;
[...]
+    else if (c == ',') p++ ;
[...]
+    else return 0 ;
[...]

ERROR: trailing statements should be on next line
#1835: FILE: tests/tcg/i386/litmus/utils.c:642:
+    else if (c == ',') p++ ;

ERROR: braces {} are necessary for all arms of this statement
#1835: FILE: tests/tcg/i386/litmus/utils.c:642:
+    else if (c == ',') p++ ;
[...]
+    else return 0 ;
[...]

ERROR: trailing statements should be on next line
#1836: FILE: tests/tcg/i386/litmus/utils.c:643:
+    else return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#1840: FILE: tests/tcg/i386/litmus/utils.c:647:
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#1840: FILE: tests/tcg/i386/litmus/utils.c:647:
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1841: FILE: tests/tcg/i386/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#1841: FILE: tests/tcg/i386/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
                                       ^

ERROR: trailing statements should be on next line
#1841: FILE: tests/tcg/i386/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1841: FILE: tests/tcg/i386/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#1844: FILE: tests/tcg/i386/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#1844: FILE: tests/tcg/i386/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1844: FILE: tests/tcg/i386/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {
                                           ^

ERROR: space required after that ',' (ctx:VxO)
#1846: FILE: tests/tcg/i386/litmus/utils.c:653:
+  double r = strtod(p,&q) ;
                      ^

ERROR: space required before that '&' (ctx:OxV)
#1846: FILE: tests/tcg/i386/litmus/utils.c:653:
+  double r = strtod(p,&q) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1848: FILE: tests/tcg/i386/litmus/utils.c:655:
+    usage(prog,d) ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#1853: FILE: tests/tcg/i386/litmus/utils.c:660:
+void parse_cmd(int argc, char **argv, cmd_t *d, cmd_t *p) {

ERROR: trailing statements should be on next line
#1859: FILE: tests/tcg/i386/litmus/utils.c:666:
+    if (!*argv) break ;

ERROR: braces {} are necessary for all arms of this statement
#1859: FILE: tests/tcg/i386/litmus/utils.c:666:
+    if (!*argv) break ;
[...]

ERROR: trailing statements should be on next line
#1861: FILE: tests/tcg/i386/litmus/utils.c:668:
+    if (fst != '-' && fst != '+') break ;

ERROR: braces {} are necessary for all arms of this statement
#1861: FILE: tests/tcg/i386/litmus/utils.c:668:
+    if (fst != '-' && fst != '+') break ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1862: FILE: tests/tcg/i386/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
                     ^

ERROR: spaces required around that '=' (ctx:VxV)
#1862: FILE: tests/tcg/i386/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
                                            ^

ERROR: trailing statements should be on next line
#1862: FILE: tests/tcg/i386/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;

ERROR: braces {} are necessary for all arms of this statement
#1862: FILE: tests/tcg/i386/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
[...]
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
[...]
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1863: FILE: tests/tcg/i386/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
                          ^

ERROR: trailing statements should be on next line
#1863: FILE: tests/tcg/i386/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;

ERROR: braces {} are necessary for all arms of this statement
#1863: FILE: tests/tcg/i386/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
[...]
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1864: FILE: tests/tcg/i386/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1864: FILE: tests/tcg/i386/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
                          ^

ERROR: braces {} are necessary for all arms of this statement
#1864: FILE: tests/tcg/i386/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1866: FILE: tests/tcg/i386/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1866: FILE: tests/tcg/i386/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1866: FILE: tests/tcg/i386/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1867: FILE: tests/tcg/i386/litmus/utils.c:674:
+      p->max_run = argint(prog,argv[0],d) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1867: FILE: tests/tcg/i386/litmus/utils.c:674:
+      p->max_run = argint(prog,argv[0],d) ;
                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1868: FILE: tests/tcg/i386/litmus/utils.c:675:
+    } else if (strcmp(*argv,"-fr") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1868: FILE: tests/tcg/i386/litmus/utils.c:675:
+    } else if (strcmp(*argv,"-fr") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1870: FILE: tests/tcg/i386/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1870: FILE: tests/tcg/i386/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1870: FILE: tests/tcg/i386/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1871: FILE: tests/tcg/i386/litmus/utils.c:678:
+      p->max_run *= argdouble(prog,argv[0],d) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1871: FILE: tests/tcg/i386/litmus/utils.c:678:
+      p->max_run *= argdouble(prog,argv[0],d) ;
                                           ^

ERROR: suspect code indent for conditional statements (4, 6)
#1872: FILE: tests/tcg/i386/litmus/utils.c:679:
+    } else if (strcmp(*argv,"-s") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1872: FILE: tests/tcg/i386/litmus/utils.c:679:
+    } else if (strcmp(*argv,"-s") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1874: FILE: tests/tcg/i386/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1874: FILE: tests/tcg/i386/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1874: FILE: tests/tcg/i386/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1875: FILE: tests/tcg/i386/litmus/utils.c:682:
+      p->size_of_test = argint(prog,argv[0],d) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1875: FILE: tests/tcg/i386/litmus/utils.c:682:
+      p->size_of_test = argint(prog,argv[0],d) ;
                                            ^

ERROR: suspect code indent for conditional statements (4, 6)
#1876: FILE: tests/tcg/i386/litmus/utils.c:683:
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1876: FILE: tests/tcg/i386/litmus/utils.c:683:
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1878: FILE: tests/tcg/i386/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1878: FILE: tests/tcg/i386/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1878: FILE: tests/tcg/i386/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1879: FILE: tests/tcg/i386/litmus/utils.c:686:
+      p->stride = argint(prog,argv[0],d) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1879: FILE: tests/tcg/i386/litmus/utils.c:686:
+      p->stride = argint(prog,argv[0],d) ;
                                      ^

ERROR: trailing statements should be on next line
#1880: FILE: tests/tcg/i386/litmus/utils.c:687:
+      if (p->stride <= 0) p->stride = 1 ;

ERROR: braces {} are necessary for all arms of this statement
#1880: FILE: tests/tcg/i386/litmus/utils.c:687:
+      if (p->stride <= 0) p->stride = 1 ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1881: FILE: tests/tcg/i386/litmus/utils.c:688:
+    } else if (strcmp(*argv,"-fs") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1881: FILE: tests/tcg/i386/litmus/utils.c:688:
+    } else if (strcmp(*argv,"-fs") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1883: FILE: tests/tcg/i386/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1883: FILE: tests/tcg/i386/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1883: FILE: tests/tcg/i386/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1884: FILE: tests/tcg/i386/litmus/utils.c:691:
+      p->size_of_test *= argdouble(prog,argv[0],d) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1884: FILE: tests/tcg/i386/litmus/utils.c:691:
+      p->size_of_test *= argdouble(prog,argv[0],d) ;
                                                ^

ERROR: suspect code indent for conditional statements (4, 6)
#1885: FILE: tests/tcg/i386/litmus/utils.c:692:
+    } else if (strcmp(*argv,"-f") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1885: FILE: tests/tcg/i386/litmus/utils.c:692:
+    } else if (strcmp(*argv,"-f") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1887: FILE: tests/tcg/i386/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1887: FILE: tests/tcg/i386/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1887: FILE: tests/tcg/i386/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1888: FILE: tests/tcg/i386/litmus/utils.c:695:
+      double f = argdouble(prog,argv[0],d) ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1888: FILE: tests/tcg/i386/litmus/utils.c:695:
+      double f = argdouble(prog,argv[0],d) ;
                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#1891: FILE: tests/tcg/i386/litmus/utils.c:698:
+    } else if (strcmp(*argv,"-n") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1891: FILE: tests/tcg/i386/litmus/utils.c:698:
+    } else if (strcmp(*argv,"-n") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1893: FILE: tests/tcg/i386/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1893: FILE: tests/tcg/i386/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1893: FILE: tests/tcg/i386/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1894: FILE: tests/tcg/i386/litmus/utils.c:701:
+      p->n_exe = argint(prog,argv[0],d) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#1894: FILE: tests/tcg/i386/litmus/utils.c:701:
+      p->n_exe = argint(prog,argv[0],d) ;
                                     ^

ERROR: trailing statements should be on next line
#1895: FILE: tests/tcg/i386/litmus/utils.c:702:
+      if (p->n_exe < 1) p->n_exe = 1 ;

ERROR: braces {} are necessary for all arms of this statement
#1895: FILE: tests/tcg/i386/litmus/utils.c:702:
+      if (p->n_exe < 1) p->n_exe = 1 ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1896: FILE: tests/tcg/i386/litmus/utils.c:703:
+    } else if (strcmp(*argv,"-a") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1896: FILE: tests/tcg/i386/litmus/utils.c:703:
+    } else if (strcmp(*argv,"-a") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1898: FILE: tests/tcg/i386/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1898: FILE: tests/tcg/i386/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1898: FILE: tests/tcg/i386/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1899: FILE: tests/tcg/i386/litmus/utils.c:706:
+      int a = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1899: FILE: tests/tcg/i386/litmus/utils.c:706:
+      int a = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1901: FILE: tests/tcg/i386/litmus/utils.c:708:
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1901: FILE: tests/tcg/i386/litmus/utils.c:708:
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1903: FILE: tests/tcg/i386/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1903: FILE: tests/tcg/i386/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1903: FILE: tests/tcg/i386/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1904: FILE: tests/tcg/i386/litmus/utils.c:711:
+      int a = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1904: FILE: tests/tcg/i386/litmus/utils.c:711:
+      int a = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1906: FILE: tests/tcg/i386/litmus/utils.c:713:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1906: FILE: tests/tcg/i386/litmus/utils.c:713:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1908: FILE: tests/tcg/i386/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1908: FILE: tests/tcg/i386/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1908: FILE: tests/tcg/i386/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1909: FILE: tests/tcg/i386/litmus/utils.c:716:
+      int i = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1909: FILE: tests/tcg/i386/litmus/utils.c:716:
+      int i = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1912: FILE: tests/tcg/i386/litmus/utils.c:719:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1912: FILE: tests/tcg/i386/litmus/utils.c:719:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1914: FILE: tests/tcg/i386/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1914: FILE: tests/tcg/i386/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1914: FILE: tests/tcg/i386/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1915: FILE: tests/tcg/i386/litmus/utils.c:722:
+      cpus_t *cpus = argcpus(prog,argv[0],d) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1915: FILE: tests/tcg/i386/litmus/utils.c:722:
+      cpus_t *cpus = argcpus(prog,argv[0],d) ;
                                          ^

ERROR: suspect code indent for conditional statements (4, 6)
#1917: FILE: tests/tcg/i386/litmus/utils.c:724:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#1917: FILE: tests/tcg/i386/litmus/utils.c:724:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1919: FILE: tests/tcg/i386/litmus/utils.c:726:
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
+      p->aff_mode = aff_custom ;

ERROR: space required after that ',' (ctx:VxV)
#1919: FILE: tests/tcg/i386/litmus/utils.c:726:
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
                                                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#1921: FILE: tests/tcg/i386/litmus/utils.c:728:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#1921: FILE: tests/tcg/i386/litmus/utils.c:728:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1923: FILE: tests/tcg/i386/litmus/utils.c:730:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_scan ;

ERROR: space required after that ',' (ctx:VxV)
#1923: FILE: tests/tcg/i386/litmus/utils.c:730:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
                                                   ^

ERROR: suspect code indent for conditional statements (4, 6)
#1925: FILE: tests/tcg/i386/litmus/utils.c:732:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#1925: FILE: tests/tcg/i386/litmus/utils.c:732:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1927: FILE: tests/tcg/i386/litmus/utils.c:734:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
+      p->aff_mode = aff_topo ;

ERROR: space required after that ',' (ctx:VxV)
#1927: FILE: tests/tcg/i386/litmus/utils.c:734:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
                                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1930: FILE: tests/tcg/i386/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1930: FILE: tests/tcg/i386/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1930: FILE: tests/tcg/i386/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1932: FILE: tests/tcg/i386/litmus/utils.c:739:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#1932: FILE: tests/tcg/i386/litmus/utils.c:739:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1934: FILE: tests/tcg/i386/litmus/utils.c:741:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
+      p->shuffle = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#1934: FILE: tests/tcg/i386/litmus/utils.c:741:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
                                               ^

ERROR: suspect code indent for conditional statements (4, 6)
#1936: FILE: tests/tcg/i386/litmus/utils.c:743:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
+      p->shuffle = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1936: FILE: tests/tcg/i386/litmus/utils.c:743:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
                                               ^

ERROR: suspect code indent for conditional statements (4, 6)
#1938: FILE: tests/tcg/i386/litmus/utils.c:745:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
+      p->speedcheck = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#1938: FILE: tests/tcg/i386/litmus/utils.c:745:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
                                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1940: FILE: tests/tcg/i386/litmus/utils.c:747:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
+      p->speedcheck = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1940: FILE: tests/tcg/i386/litmus/utils.c:747:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
                                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1942: FILE: tests/tcg/i386/litmus/utils.c:749:
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
+      p->fix = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#1942: FILE: tests/tcg/i386/litmus/utils.c:749:
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#1944: FILE: tests/tcg/i386/litmus/utils.c:751:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
+      p->verbose_barrier++ ;

ERROR: space required after that ',' (ctx:VxV)
#1944: FILE: tests/tcg/i386/litmus/utils.c:751:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1946: FILE: tests/tcg/i386/litmus/utils.c:753:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
+      p->verbose_barrier = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1946: FILE: tests/tcg/i386/litmus/utils.c:753:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#1948: FILE: tests/tcg/i386/litmus/utils.c:755:
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
+      p->prelude = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1948: FILE: tests/tcg/i386/litmus/utils.c:755:
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
                                              ^

ERROR: suspect code indent for conditional statements (4, 6)
#1950: FILE: tests/tcg/i386/litmus/utils.c:757:
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1950: FILE: tests/tcg/i386/litmus/utils.c:757:
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1952: FILE: tests/tcg/i386/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1952: FILE: tests/tcg/i386/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1952: FILE: tests/tcg/i386/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1953: FILE: tests/tcg/i386/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#1953: FILE: tests/tcg/i386/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1953: FILE: tests/tcg/i386/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                             ^

ERROR: suspect code indent for conditional statements (4, 6)
#1954: FILE: tests/tcg/i386/litmus/utils.c:761:
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1954: FILE: tests/tcg/i386/litmus/utils.c:761:
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1956: FILE: tests/tcg/i386/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1956: FILE: tests/tcg/i386/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1956: FILE: tests/tcg/i386/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1957: FILE: tests/tcg/i386/litmus/utils.c:764:
+      int da = argint(prog,argv[0],d) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1957: FILE: tests/tcg/i386/litmus/utils.c:764:
+      int da = argint(prog,argv[0],d) ;
                                   ^

ERROR: trailing statements should be on next line
#1958: FILE: tests/tcg/i386/litmus/utils.c:765:
+      for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;

ERROR: braces {} are necessary even for single statement blocks
#1958: FILE: tests/tcg/i386/litmus/utils.c:765:
+      for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;

ERROR: suspect code indent for conditional statements (4, 6)
#1959: FILE: tests/tcg/i386/litmus/utils.c:766:
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/i386/litmus/utils.c:766:
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1961: FILE: tests/tcg/i386/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1961: FILE: tests/tcg/i386/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1961: FILE: tests/tcg/i386/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1962: FILE: tests/tcg/i386/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1962: FILE: tests/tcg/i386/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1962: FILE: tests/tcg/i386/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                                 ^

ERROR: suspect code indent for conditional statements (4, 6)
#1963: FILE: tests/tcg/i386/litmus/utils.c:770:
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1963: FILE: tests/tcg/i386/litmus/utils.c:770:
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1965: FILE: tests/tcg/i386/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1965: FILE: tests/tcg/i386/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1965: FILE: tests/tcg/i386/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/i386/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/i386/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/i386/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#1967: FILE: tests/tcg/i386/litmus/utils.c:774:
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1967: FILE: tests/tcg/i386/litmus/utils.c:774:
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1969: FILE: tests/tcg/i386/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1969: FILE: tests/tcg/i386/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1969: FILE: tests/tcg/i386/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1970: FILE: tests/tcg/i386/litmus/utils.c:777:
+      int prs = argint(prog,argv[0],d) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1970: FILE: tests/tcg/i386/litmus/utils.c:777:
+      int prs = argint(prog,argv[0],d) ;
                                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#1972: FILE: tests/tcg/i386/litmus/utils.c:779:
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#1972: FILE: tests/tcg/i386/litmus/utils.c:779:
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1974: FILE: tests/tcg/i386/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#1974: FILE: tests/tcg/i386/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#1974: FILE: tests/tcg/i386/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1975: FILE: tests/tcg/i386/litmus/utils.c:782:
+      int i = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1975: FILE: tests/tcg/i386/litmus/utils.c:782:
+      int i = argint(prog,argv[0],d) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1977: FILE: tests/tcg/i386/litmus/utils.c:784:
+    } else usage(prog,d) ;
                      ^

ERROR: trailing statements should be on next line
#1977: FILE: tests/tcg/i386/litmus/utils.c:784:
+    } else usage(prog,d) ;

ERROR: trailing statements should be on next line
#1981: FILE: tests/tcg/i386/litmus/utils.c:788:
+  if (argc == 0) return ;

ERROR: braces {} are necessary for all arms of this statement
#1981: FILE: tests/tcg/i386/litmus/utils.c:788:
+  if (argc == 0) return ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#1982: FILE: tests/tcg/i386/litmus/utils.c:789:
+  usage(prog,d) ;
             ^

ERROR: open brace '{' following function declarations go on the next line
#1991: FILE: tests/tcg/i386/litmus/utils.c:798:
+pm_t *pm_create(void) {

ERROR: space required after that ',' (ctx:VxV)
#1993: FILE: tests/tcg/i386/litmus/utils.c:800:
+  int ret = pthread_mutex_init(p,NULL) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1994: FILE: tests/tcg/i386/litmus/utils.c:801:
+  if (ret) { errexit("mutex_init",ret) ; }
                                  ^

ERROR: trailing statements should be on next line
#1994: FILE: tests/tcg/i386/litmus/utils.c:801:
+  if (ret) { errexit("mutex_init",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#1998: FILE: tests/tcg/i386/litmus/utils.c:805:
+void pm_free(pm_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2002: FILE: tests/tcg/i386/litmus/utils.c:809:
+void pm_lock(pm_t *m) {

ERROR: space required after that ',' (ctx:VxV)
#2004: FILE: tests/tcg/i386/litmus/utils.c:811:
+  if (ret) { errexit("mutex_lock",ret) ; }
                                  ^

ERROR: trailing statements should be on next line
#2004: FILE: tests/tcg/i386/litmus/utils.c:811:
+  if (ret) { errexit("mutex_lock",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#2007: FILE: tests/tcg/i386/litmus/utils.c:814:
+void pm_unlock(pm_t *m) {

ERROR: space required after that ',' (ctx:VxV)
#2009: FILE: tests/tcg/i386/litmus/utils.c:816:
+  if (ret) { errexit("mutex_unlock",ret) ; }
                                    ^

ERROR: trailing statements should be on next line
#2009: FILE: tests/tcg/i386/litmus/utils.c:816:
+  if (ret) { errexit("mutex_unlock",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#2014: FILE: tests/tcg/i386/litmus/utils.c:821:
+pc_t *pc_create(void) {

ERROR: space required after that ',' (ctx:VxV)
#2018: FILE: tests/tcg/i386/litmus/utils.c:825:
+  int e = pthread_cond_init(p->c_cond,NULL) ;
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#2019: FILE: tests/tcg/i386/litmus/utils.c:826:
+  if (e) { errexit("cond_init",e); }
                               ^

ERROR: trailing statements should be on next line
#2019: FILE: tests/tcg/i386/litmus/utils.c:826:
+  if (e) { errexit("cond_init",e); }

ERROR: open brace '{' following function declarations go on the next line
#2023: FILE: tests/tcg/i386/litmus/utils.c:830:
+void pc_free(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2029: FILE: tests/tcg/i386/litmus/utils.c:836:
+static void pc_lock(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2033: FILE: tests/tcg/i386/litmus/utils.c:840:
+static void pc_unlock(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2037: FILE: tests/tcg/i386/litmus/utils.c:844:
+void pc_wait(pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#2039: FILE: tests/tcg/i386/litmus/utils.c:846:
+  if (e) { errexit("cond_wait",e) ; }
                               ^

ERROR: trailing statements should be on next line
#2039: FILE: tests/tcg/i386/litmus/utils.c:846:
+  if (e) { errexit("cond_wait",e) ; }

ERROR: space prohibited between function name and open parenthesis '('
#2042: FILE: tests/tcg/i386/litmus/utils.c:849:
+void pc_broadcast (pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#2044: FILE: tests/tcg/i386/litmus/utils.c:851:
+  if (e) { errexit("cond_broadcast",e) ; }
                                    ^

ERROR: trailing statements should be on next line
#2044: FILE: tests/tcg/i386/litmus/utils.c:851:
+  if (e) { errexit("cond_broadcast",e) ; }

ERROR: open brace '{' following function declarations go on the next line
#2047: FILE: tests/tcg/i386/litmus/utils.c:854:
+static void pc_signal(pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#2049: FILE: tests/tcg/i386/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;
                               ^

ERROR: trailing statements should be on next line
#2049: FILE: tests/tcg/i386/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;

ERROR: braces {} are necessary for all arms of this statement
#2049: FILE: tests/tcg/i386/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#2056: FILE: tests/tcg/i386/litmus/utils.c:863:
+pb_t *pb_create(int nprocs) {

ERROR: open brace '{' following function declarations go on the next line
#2064: FILE: tests/tcg/i386/litmus/utils.c:871:
+void pb_free(pb_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2070: FILE: tests/tcg/i386/litmus/utils.c:877:
+void pb_wait(pb_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#2079: FILE: tests/tcg/i386/litmus/utils.c:886:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#2089: FILE: tests/tcg/i386/litmus/utils.c:896:
+po_t *po_create(int nprocs) {

ERROR: open brace '{' following function declarations go on the next line
#2098: FILE: tests/tcg/i386/litmus/utils.c:905:
+void po_free(po_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2103: FILE: tests/tcg/i386/litmus/utils.c:910:
+void po_reinit(po_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#2113: FILE: tests/tcg/i386/litmus/utils.c:920:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#2120: FILE: tests/tcg/i386/litmus/utils.c:927:
+int po_wait(po_t *p, int v) {

ERROR: suspect code indent for conditional statements (4, 6)
#2130: FILE: tests/tcg/i386/litmus/utils.c:937:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#2142: FILE: tests/tcg/i386/litmus/utils.c:949:
+op_t *op_create(void) {

ERROR: open brace '{' following function declarations go on the next line
#2150: FILE: tests/tcg/i386/litmus/utils.c:957:
+void op_free(op_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2155: FILE: tests/tcg/i386/litmus/utils.c:962:
+void op_set(op_t *p, void *v) {

ERROR: trailing statements should be on next line
#2157: FILE: tests/tcg/i386/litmus/utils.c:964:
+  if (p->some) { fatal("op_set") ; }

ERROR: open brace '{' following function declarations go on the next line
#2164: FILE: tests/tcg/i386/litmus/utils.c:971:
+void *op_get(op_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#2179: FILE: tests/tcg/i386/litmus/utils.c:986:
+void launch(pthread_t *th, f_t *f, void *a) {

ERROR: space required after that ',' (ctx:VxV)
#2180: FILE: tests/tcg/i386/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2180: FILE: tests/tcg/i386/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2180: FILE: tests/tcg/i386/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2181: FILE: tests/tcg/i386/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);
                                 ^

ERROR: trailing statements should be on next line
#2181: FILE: tests/tcg/i386/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);

ERROR: braces {} are necessary for all arms of this statement
#2181: FILE: tests/tcg/i386/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);
[...]

ERROR: open brace '{' following function declarations go on the next line
#2184: FILE: tests/tcg/i386/litmus/utils.c:991:
+void *join(pthread_t *th) {

ERROR: space required after that ',' (ctx:VxO)
#2186: FILE: tests/tcg/i386/litmus/utils.c:993:
+  int e = pthread_join(*th,&r) ;
                           ^

ERROR: space required before that '&' (ctx:OxV)
#2186: FILE: tests/tcg/i386/litmus/utils.c:993:
+  int e = pthread_join(*th,&r) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2187: FILE: tests/tcg/i386/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);
                                 ^

ERROR: trailing statements should be on next line
#2187: FILE: tests/tcg/i386/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);

ERROR: braces {} are necessary for all arms of this statement
#2187: FILE: tests/tcg/i386/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);
[...]

ERROR: open brace '{' following function declarations go on the next line
#2199: FILE: tests/tcg/i386/litmus/utils.c:1006:
+static void *zyva_det(void *_b) {

ERROR: space required after that ',' (ctx:VxV)
#2206: FILE: tests/tcg/i386/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;
                                  ^

ERROR: trailing statements should be on next line
#2206: FILE: tests/tcg/i386/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;

ERROR: braces {} are necessary for all arms of this statement
#2206: FILE: tests/tcg/i386/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#2208: FILE: tests/tcg/i386/litmus/utils.c:1015:
+  op_set(op,r) ;
            ^

ERROR: open brace '{' following function declarations go on the next line
#2212: FILE: tests/tcg/i386/litmus/utils.c:1019:
+op_t *launch_detached(f_t *f,void *a) {

ERROR: space required after that ',' (ctx:VxV)
#2212: FILE: tests/tcg/i386/litmus/utils.c:1019:
+op_t *launch_detached(f_t *f,void *a) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#2217: FILE: tests/tcg/i386/litmus/utils.c:1024:
+  launch(&th,zyva_det,b) ;
             ^

ERROR: space required after that ',' (ctx:VxV)
#2217: FILE: tests/tcg/i386/litmus/utils.c:1024:
+  launch(&th,zyva_det,b) ;
                      ^

ERROR: open brace '{' following function declarations go on the next line
#2221: FILE: tests/tcg/i386/litmus/utils.c:1028:
+void *join_detached(op_t *op) {

ERROR: open brace '{' following function declarations go on the next line
#2229: FILE: tests/tcg/i386/litmus/utils.c:1036:
+void *start_thread(void *_a) {

ERROR: trailing statements should be on next line
#2234: FILE: tests/tcg/i386/litmus/utils.c:1041:
+    if (f == NULL) break ;

ERROR: braces {} are necessary for all arms of this statement
#2234: FILE: tests/tcg/i386/litmus/utils.c:1041:
+    if (f == NULL) break ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#2236: FILE: tests/tcg/i386/litmus/utils.c:1043:
+    op_set(_b->op_ret,ret) ;
                      ^

ERROR: open brace '{' following function declarations go on the next line
#2245: FILE: tests/tcg/i386/litmus/utils.c:1052:
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {

ERROR: space required after that ',' (ctx:VxV)
#2245: FILE: tests/tcg/i386/litmus/utils.c:1052:
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {
                                   ^

ERROR: spaces required around that '+' (ctx:VxV)
#2248: FILE: tests/tcg/i386/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2248: FILE: tests/tcg/i386/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#2248: FILE: tests/tcg/i386/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#2253: FILE: tests/tcg/i386/litmus/utils.c:1060:
+void perm_ints(unsigned *st,int *_t, int n) {

ERROR: space required after that ',' (ctx:VxV)
#2253: FILE: tests/tcg/i386/litmus/utils.c:1060:
+void perm_ints(unsigned *st,int *_t, int n) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2254: FILE: tests/tcg/i386/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                          ^

ERROR: spaces required around that '-' (ctx:VxV)
#2254: FILE: tests/tcg/i386/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2254: FILE: tests/tcg/i386/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                              ^

ERROR: open brace '{' following function declarations go on the next line
#2257: FILE: tests/tcg/i386/litmus/utils.c:1064:
+void perm_funs(unsigned *st,f_t *fun[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#2257: FILE: tests/tcg/i386/litmus/utils.c:1064:
+void perm_funs(unsigned *st,f_t *fun[], int n) {
                            ^

ERROR: spaces required around that '-' (ctx:VxV)
#2259: FILE: tests/tcg/i386/litmus/utils.c:1066:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#2260: FILE: tests/tcg/i386/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2260: FILE: tests/tcg/i386/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#2260: FILE: tests/tcg/i386/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#2266: FILE: tests/tcg/i386/litmus/utils.c:1073:
+void perm_ops(unsigned *st,op_t *op[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#2266: FILE: tests/tcg/i386/litmus/utils.c:1073:
+void perm_ops(unsigned *st,op_t *op[], int n) {
                           ^

ERROR: spaces required around that '-' (ctx:VxV)
#2268: FILE: tests/tcg/i386/litmus/utils.c:1075:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#2269: FILE: tests/tcg/i386/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2269: FILE: tests/tcg/i386/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#2269: FILE: tests/tcg/i386/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#2275: FILE: tests/tcg/i386/litmus/utils.c:1082:
+void perm_threads(unsigned *st,pthread_t thread[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#2275: FILE: tests/tcg/i386/litmus/utils.c:1082:
+void perm_threads(unsigned *st,pthread_t thread[], int n) {
                               ^

ERROR: spaces required around that '-' (ctx:VxV)
#2277: FILE: tests/tcg/i386/litmus/utils.c:1084:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#2278: FILE: tests/tcg/i386/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2278: FILE: tests/tcg/i386/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#2278: FILE: tests/tcg/i386/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#2284: FILE: tests/tcg/i386/litmus/utils.c:1091:
+static int int_cmp(const void *_p, const void *_q) {

ERROR: trailing statements should be on next line
#2287: FILE: tests/tcg/i386/litmus/utils.c:1094:
+  if (x < y) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#2287: FILE: tests/tcg/i386/litmus/utils.c:1094:
+  if (x < y) return -1 ;
[...]
+  else if (x > y) return 1 ;
[...]
+  else return 0 ;
[...]

ERROR: trailing statements should be on next line
#2288: FILE: tests/tcg/i386/litmus/utils.c:1095:
+  else if (x > y) return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#2288: FILE: tests/tcg/i386/litmus/utils.c:1095:
+  else if (x > y) return 1 ;
[...]
+  else return 0 ;
[...]

ERROR: trailing statements should be on next line
#2289: FILE: tests/tcg/i386/litmus/utils.c:1096:
+  else return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#2292: FILE: tests/tcg/i386/litmus/utils.c:1099:
+int check_shuffle(int **t, int *min, int sz) {

ERROR: spaces required around that '*' (ctx:VxV)
#2293: FILE: tests/tcg/i386/litmus/utils.c:1100:
+  int *idx = malloc_check(sizeof(*idx)*sz) ;
                                       ^

ERROR: spaces required around that '=' (ctx:VxV)
#2294: FILE: tests/tcg/i386/litmus/utils.c:1101:
+  for (int k=0 ; k < sz ; k++) {
             ^

ERROR: do not use C99 // comments
#2296: FILE: tests/tcg/i386/litmus/utils.c:1103:
+    //    fprintf(stderr," %i",idx[k]) ;

ERROR: do not use C99 // comments
#2298: FILE: tests/tcg/i386/litmus/utils.c:1105:
+  //  fprintf(stderr,"\n") ;

ERROR: space required after that ',' (ctx:VxV)
#2299: FILE: tests/tcg/i386/litmus/utils.c:1106:
+  qsort(&idx[0],sz, sizeof(idx[0]), int_cmp) ;
                ^

ERROR: spaces required around that '=' (ctx:VxV)
#2300: FILE: tests/tcg/i386/litmus/utils.c:1107:
+  for (int k=0 ; k < sz ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#2301: FILE: tests/tcg/i386/litmus/utils.c:1108:
+    if (idx[k] != k) {
+      free(idx) ;

ERROR: open brace '{' following function declarations go on the next line
#2317: FILE: tests/tcg/i386/litmus/utils.c:1124:
+tsc_t timeofday(void) {

ERROR: space required after that ',' (ctx:VxV)
#2319: FILE: tests/tcg/i386/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2319: FILE: tests/tcg/i386/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
                                                    ^

ERROR: trailing statements should be on next line
#2319: FILE: tests/tcg/i386/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;

ERROR: braces {} are necessary for all arms of this statement
#2319: FILE: tests/tcg/i386/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#2323: FILE: tests/tcg/i386/litmus/utils.c:1130:
+double tsc_ratio(tsc_t t1, tsc_t t2) {

ERROR: open brace '{' following function declarations go on the next line
#2328: FILE: tests/tcg/i386/litmus/utils.c:1135:
+double tsc_millions(tsc_t t) {

ERROR: open brace '{' following function declarations go on the next line
#2336: FILE: tests/tcg/i386/litmus/utils.c:1143:
+int find_string(char *t[], int sz, char *s) {

ERROR: space required after that ',' (ctx:VxV)
#2338: FILE: tests/tcg/i386/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;
                    ^

ERROR: trailing statements should be on next line
#2338: FILE: tests/tcg/i386/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;

ERROR: braces {} are necessary for all arms of this statement
#2338: FILE: tests/tcg/i386/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#2378: FILE: tests/tcg/i386/litmus/utils.h:31:
+int log_error(const char *fmt,...) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2382: FILE: tests/tcg/i386/litmus/utils.h:35:
+void errexit(char *msg,int e) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2386: FILE: tests/tcg/i386/litmus/utils.h:39:
+int max(int n,int m) ;
              ^

ERROR: space prohibited between function name and open parenthesis '('
#2388: FILE: tests/tcg/i386/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;

ERROR: space required after that ',' (ctx:VxV)
#2388: FILE: tests/tcg/i386/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2388: FILE: tests/tcg/i386/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2394: FILE: tests/tcg/i386/litmus/utils.h:47:
+void cat_file(char *path,char *msg,FILE *out) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#2394: FILE: tests/tcg/i386/litmus/utils.h:47:
+void cat_file(char *path,char *msg,FILE *out) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2410: FILE: tests/tcg/i386/litmus/utils.h:63:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) ;
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#2418: FILE: tests/tcg/i386/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
          ^

ERROR: space required after that ',' (ctx:VxV)
#2418: FILE: tests/tcg/i386/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#2418: FILE: tests/tcg/i386/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2418: FILE: tests/tcg/i386/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2418: FILE: tests/tcg/i386/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                                            ^

ERROR: open brace '{' following enum go on the same line
#2456: FILE: tests/tcg/i386/litmus/utils.h:109:
+typedef enum
+  { aff_none, aff_incr, aff_random, aff_custom,

ERROR: "foo * bar" should be "foo *bar"
#2480: FILE: tests/tcg/i386/litmus/utils.h:133:
+  ints_t * delta_tb ;

ERROR: space prohibited between function name and open parenthesis '('
#2520: FILE: tests/tcg/i386/litmus/utils.h:173:
+void pc_broadcast (pc_t *p) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2527: FILE: tests/tcg/i386/litmus/utils.h:180:
+  volatile unsigned int count ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2528: FILE: tests/tcg/i386/litmus/utils.h:181:
+  volatile int turn ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2545: FILE: tests/tcg/i386/litmus/utils.h:198:
+  volatile int val ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2546: FILE: tests/tcg/i386/litmus/utils.h:199:
+  volatile int turn ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2560: FILE: tests/tcg/i386/litmus/utils.h:213:
+  int volatile some ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2561: FILE: tests/tcg/i386/litmus/utils.h:214:
+  void * volatile val ;

ERROR: space required after that ',' (ctx:VxV)
#2579: FILE: tests/tcg/i386/litmus/utils.h:232:
+op_t *launch_detached(f_t *f,void *a) ;
                             ^

ERROR: space required after that ',' (ctx:VxO)
#2586: FILE: tests/tcg/i386/litmus/utils.h:239:
+  op_t *op_arg,*op_ret ;
               ^

ERROR: space required before that '*' (ctx:OxV)
#2586: FILE: tests/tcg/i386/litmus/utils.h:239:
+  op_t *op_arg,*op_ret ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#2598: FILE: tests/tcg/i386/litmus/utils.h:251:
+void perm_prefix_ints(st_t *st,int t[], int used, int sz) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#2599: FILE: tests/tcg/i386/litmus/utils.h:252:
+void perm_ints(st_t *st,int t[], int sz) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#2600: FILE: tests/tcg/i386/litmus/utils.h:253:
+void perm_funs(st_t *st,f_t *t[], int sz) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#2601: FILE: tests/tcg/i386/litmus/utils.h:254:
+void perm_threads(st_t *st,pthread_t t[], int sz) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2602: FILE: tests/tcg/i386/litmus/utils.h:255:
+void perm_ops(st_t *st,op_t *t[], int sz) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2620: FILE: tests/tcg/i386/litmus/utils.h:273:
+int find_string(char *t[],int sz,char *s) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#2620: FILE: tests/tcg/i386/litmus/utils.h:273:
+int find_string(char *t[],int sz,char *s) ;
                                 ^

total: 1074 errors, 8 warnings, 2528 lines checked

Your patch has style problems, please review.  If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.

Checking PATCH 2/3: tests/tcg: Add aarch64 litmus tests...
ERROR: space required after that ',' (ctx:VxV)
#49: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#58: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#58: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#58: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#59: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#59: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#63: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#63: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#63: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#63: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#63: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#67: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#67: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#86: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:70:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#93: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x2) {

ERROR: space required after that ',' (ctx:VxV)
#93: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x2) {
                                           ^

ERROR: storage class should be at the beginning of the declaration
#93: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x2) {

ERROR: inline keyword should sit between storage class and type
#93: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x2) {

ERROR: open brace '{' following function declarations go on the next line
#107: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:91:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#107: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:91:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#107: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:91:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#117: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:101:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#123: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:107:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#126: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:110:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#133: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:117:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#138: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:122:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#139: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#139: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#139: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#139: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#142: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:126:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#145: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#145: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#148: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:132:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#153: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:137:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);

ERROR: space required after that ',' (ctx:VxV)
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#154: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f]);
                                                                                
        ^

ERROR: open brace '{' following function declarations go on the next line
#157: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:141:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#159: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#159: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#159: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#159: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#166: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:150:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#170: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:154:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#171: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:155:
+  _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#172: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:156:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#173: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:157:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#175: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:159:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#178: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:162:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#187: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:171:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#188: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:172:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#201: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:185:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#204: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:188:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#205: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM00, check_globals 
failed");

ERROR: trailing statements should be on next line
#205: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM00, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#205: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM00, check_globals 
failed");
[...]

WARNING: line over 80 characters
#206: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM00, check_globals 
failed");

ERROR: trailing statements should be on next line
#206: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM00, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#206: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM00, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#225: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:209:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#230: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#233: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:217:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#237: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:221:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#237: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:221:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#238: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#238: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#238: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#253: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:237:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
 ^

ERROR: space required after that ',' (ctx:VxV)
#253: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:237:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
                         ^

ERROR: spaces required around that ':' (ctx:ExV)
#254: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:238:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#254: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:238:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#255: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:239:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#255: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:239:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#263: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:247:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#268: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#268: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#268: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#271: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:255:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#277: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:261:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#277: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:261:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#278: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#278: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#278: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#293: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:277:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#293: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:277:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#294: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:278:
+:[x1] "r" (&_a->y[_i]),"[x2]" (-1),[x3] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#294: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:278:
+:[x1] "r" (&_a->y[_i]),"[x2]" (-1),[x3] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#294: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:278:
+:[x1] "r" (&_a->y[_i]),"[x2]" (-1),[x3] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#295: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:279:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#295: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:279:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#313: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:297:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#319: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:303:
+  f_t *fun[] = {&P0,&P1};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#319: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:303:
+  f_t *fun[] = {&P0,&P1};
                     ^

ERROR: spaces required around that '-' (ctx:VxV)
#325: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:309:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#331: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:315:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#333: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:317:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#337: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:321:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#337: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:321:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#337: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:321:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#337: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:321:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#339: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:323:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#339: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:323:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#339: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:323:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#339: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:323:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#340: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:324:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#340: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:324:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#341: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:325:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#341: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:325:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#341: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:325:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#343: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:327:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#343: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:327:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#343: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:327:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#343: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:327:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#344: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:328:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#344: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:328:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#348: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:332:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#348: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:332:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#354: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:338:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_1_x2_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#357: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:341:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#357: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:341:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#357: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:341:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#358: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:342:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#368: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:352:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#369: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:353:
+  fprintf(out,"Test ARMARM00 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#370: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:354:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#370: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:354:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#371: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:355:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#373: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:357:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#373: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:357:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#373: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:357:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#373: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:357:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#374: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:358:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#375: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:359:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#375: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:359:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#375: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:359:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#376: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:360:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0) is %svalidated\n",cond ? 
"" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#376: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:360:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0) is %svalidated\n",cond ? 
"" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#376: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:360:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0) is %svalidated\n",cond ? 
"" : "NOT ");
                                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#377: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:361:
+  fprintf(out,"Hash=8b05db686103708c048891dddc96e8bd\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#378: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:362:
+  fprintf(out,"Com=Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#379: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:363:
+  fprintf(out,"Orig=PodWWPL RfeLA PodRRAP Fre\n");
              ^

ERROR: line over 90 characters
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#382: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:366:
+  fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#383: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:367:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#385: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:369:
+  fprintf(out,"Time ARMARM00 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#385: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:369:
+  fprintf(out,"Time ARMARM00 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#390: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:374:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#390: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:374:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#390: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:374:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#399: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:383:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#399: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:383:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#402: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:386:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#402: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:386:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#402: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:386:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#402: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:386:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#411: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:395:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#411: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:395:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#411: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:395:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#411: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:395:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#415: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:399:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#418: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:402:
+    log_error( "ARMARM00: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#418: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:402:
+    log_error( "ARMARM00: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#418: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:402:
+    log_error( "ARMARM00: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#418: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:402:
+    log_error( "ARMARM00: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#419: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:403:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#420: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:404:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#421: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:405:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#421: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:405:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#422: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:406:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#424: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:408:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#426: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:410:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#430: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:414:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#435: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:419:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#440: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:424:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#448: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:432:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#448: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:432:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#448: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:432:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#453: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:437:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#453: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:437:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#453: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:437:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#455: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:439:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#458: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:442:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#461: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:445:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#464: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:448:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#467: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:451:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#473: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:457:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#474: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:458:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#474: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:458:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#481: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:465:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#483: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:467:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM00, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#486: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:470:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#499: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:483:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#499: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:483:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#499: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:483:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#499: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:483:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#499: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:483:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#505: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:489:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#506: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:490:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#511: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:495:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#513: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:497:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#513: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:497:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#513: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:497:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#513: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:497:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#513: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:497:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#514: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:498:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#514: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:498:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#515: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:499:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#515: FILE: tests/tcg/aarch64/litmus/ARMARM00.c:499:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#556: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#565: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#565: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#565: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#566: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#566: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#570: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#570: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#570: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#570: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#570: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#574: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#574: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#593: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:70:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#600: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x3) {

ERROR: space required after that ',' (ctx:VxV)
#600: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x3) {
                                           ^

ERROR: storage class should be at the beginning of the declaration
#600: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x3) {

ERROR: inline keyword should sit between storage class and type
#600: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:77:
+inline static int final_cond(int _out_1_x0,int _out_1_x3) {

ERROR: open brace '{' following function declarations go on the next line
#614: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:91:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#614: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:91:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#614: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:91:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#624: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:101:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#630: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:107:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#633: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:110:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#640: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:117:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#645: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:122:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#646: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#646: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#646: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#646: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#649: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:126:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#652: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#652: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#655: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:132:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#660: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:137:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#661: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f]);
                                                                                
        ^

ERROR: open brace '{' following function declarations go on the next line
#664: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:141:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#666: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#666: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#666: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#666: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#673: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:150:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#677: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:154:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#678: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:155:
+  _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#679: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:156:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#680: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:157:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#682: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:159:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#685: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:162:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#694: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:171:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#695: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:172:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#708: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:185:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#711: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:188:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#712: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM01, check_globals 
failed");

ERROR: trailing statements should be on next line
#712: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM01, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#712: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM01, check_globals 
failed");
[...]

WARNING: line over 80 characters
#713: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM01, check_globals 
failed");

ERROR: trailing statements should be on next line
#713: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM01, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#713: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM01, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#732: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:209:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#737: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#737: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#737: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#740: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:217:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#744: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:221:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#744: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:221:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#745: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#745: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#745: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:222:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#760: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:237:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
 ^

ERROR: space required after that ',' (ctx:VxV)
#760: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:237:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
                         ^

ERROR: spaces required around that ':' (ctx:ExV)
#761: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:238:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#761: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:238:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#762: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:239:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#762: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:239:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#770: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:247:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#775: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#775: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#775: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#778: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:255:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#784: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:261:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#784: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:261:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#785: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#785: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#785: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:262:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#803: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:280:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#803: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:280:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#803: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:280:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: spaces required around that ':' (ctx:ExV)
#804: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:281:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#804: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:281:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#804: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:281:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#805: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:282:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#805: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:282:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#823: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:300:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#829: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:306:
+  f_t *fun[] = {&P0,&P1};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#829: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:306:
+  f_t *fun[] = {&P0,&P1};
                     ^

ERROR: spaces required around that '-' (ctx:VxV)
#835: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:312:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#841: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:318:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#843: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:320:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#847: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:324:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#847: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:324:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#847: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:324:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#847: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:324:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#849: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:326:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#849: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:326:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#849: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:326:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#849: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:326:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#850: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:327:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#850: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:327:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#851: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:328:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#851: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:328:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#851: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:328:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#853: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:330:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#853: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:330:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#853: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:330:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#853: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:330:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#854: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:331:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#854: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:331:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#858: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:335:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#858: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:335:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#864: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:341:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_1_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#867: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:344:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#867: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:344:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#867: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:344:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#868: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:345:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#878: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:355:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#879: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:356:
+  fprintf(out,"Test ARMARM01 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#880: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:357:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#880: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:357:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#881: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:358:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#883: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:360:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#883: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:360:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#883: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:360:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#883: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:360:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#884: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:361:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#885: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:362:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#885: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:362:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#885: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:362:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#886: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:363:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#886: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:363:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#886: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:363:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");
                                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#887: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:364:
+  fprintf(out,"Hash=e5d401d98b0063559060cb31236f54de\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#888: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:365:
+  fprintf(out,"Com=Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#889: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:366:
+  fprintf(out,"Orig=PodWWPL RfeLP DpAddrdR Fre\n");
              ^

ERROR: line over 90 characters
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#892: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:369:
+  fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#893: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:370:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#895: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:372:
+  fprintf(out,"Time ARMARM01 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#895: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:372:
+  fprintf(out,"Time ARMARM01 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#900: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:377:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#900: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:377:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#900: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:377:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#909: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:386:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#909: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:386:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#912: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:389:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#912: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:389:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#912: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:389:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#912: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:389:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#921: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:398:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#921: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:398:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#921: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:398:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#921: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:398:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#925: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:402:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#928: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:405:
+    log_error( "ARMARM01: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#928: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:405:
+    log_error( "ARMARM01: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#928: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:405:
+    log_error( "ARMARM01: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#928: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:405:
+    log_error( "ARMARM01: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#929: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:406:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#930: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:407:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#931: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:408:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#931: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:408:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#932: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:409:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#934: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:411:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#936: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:413:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#940: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:417:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#945: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:422:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#950: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:427:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#958: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:435:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#958: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:435:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#958: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:435:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#963: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:440:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#963: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:440:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#963: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:440:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#965: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:442:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#968: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:445:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#971: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:448:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#974: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:451:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#977: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:454:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#983: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:460:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#984: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:461:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#984: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:461:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#991: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:468:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#993: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:470:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM01, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#996: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:473:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1009: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:486:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1009: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:486:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1009: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:486:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1009: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:486:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1009: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:486:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#1015: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:492:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#1016: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:493:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#1021: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:498:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#1023: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:500:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#1023: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:500:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#1023: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:500:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#1023: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:500:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#1023: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:500:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1024: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:501:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#1024: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:501:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#1025: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:502:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#1025: FILE: tests/tcg/aarch64/litmus/ARMARM01.c:502:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#1066: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#1075: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#1075: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#1075: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#1076: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#1076: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#1080: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#1080: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1080: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#1080: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#1080: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#1084: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#1084: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1105: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:72:
+  int volatile *barrier;

WARNING: line over 80 characters
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {

ERROR: open brace '{' following function declarations go on the next line
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {

ERROR: space required after that ',' (ctx:VxV)
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {
                                                                       ^

ERROR: storage class should be at the beginning of the declaration
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {

ERROR: inline keyword should sit between storage class and type
#1112: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int 
_out_2_x3) {

ERROR: trailing whitespace
#1124: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:91:
+  label00: /* occs=2 */ $

ERROR: open brace '{' following function declarations go on the next line
#1138: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:105:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#1138: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:105:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#1138: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:105:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#1148: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:115:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1156: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:123:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#1159: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:126:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#1166: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:133:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#1171: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:138:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#1172: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:139:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1172: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:139:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1172: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:139:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1172: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:139:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#1175: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:142:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#1178: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:145:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1178: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:145:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#1181: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:148:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#1186: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:153:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
       ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1187: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:154:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X3=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x3_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                                                                ^

ERROR: open brace '{' following function declarations go on the next line
#1190: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:157:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#1192: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:159:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#1192: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:159:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1192: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:159:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1192: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:159:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#1199: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:166:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#1203: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:170:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1204: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:171:
+  _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1205: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:172:
+  _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1206: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:173:
+  _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1207: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:174:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#1208: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:175:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#1210: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:177:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#1213: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:180:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#1224: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:191:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#1225: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:192:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1240: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:207:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#1243: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:210:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#1244: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:211:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM02, check_globals 
failed");

ERROR: trailing statements should be on next line
#1244: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:211:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM02, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#1244: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:211:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM02, check_globals 
failed");
[...]

WARNING: line over 80 characters
#1245: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:212:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM02, check_globals 
failed");

ERROR: trailing statements should be on next line
#1245: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:212:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM02, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#1245: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:212:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM02, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#1264: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:231:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#1269: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:236:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1269: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:236:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1269: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:236:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1272: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:239:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#1276: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:243:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#1276: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:243:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1277: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:244:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#1277: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:244:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1277: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:244:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#1292: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:259:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
 ^

ERROR: space required after that ',' (ctx:VxV)
#1292: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:259:
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
                         ^

ERROR: spaces required around that ':' (ctx:ExV)
#1293: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:260:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#1293: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:260:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#1294: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:261:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#1294: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:261:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#1302: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:269:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#1307: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:274:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1307: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:274:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1307: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:274:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1310: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:277:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#1316: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:283:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#1316: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:283:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1317: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:284:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#1317: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:284:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1317: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:284:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#1335: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:302:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#1335: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:302:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1335: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:302:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: spaces required around that ':' (ctx:ExV)
#1336: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:303:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#1336: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:303:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1336: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:303:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#1337: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:304:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#1337: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:304:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#1345: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:312:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#1350: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:317:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1350: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:317:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1350: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:317:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1353: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:320:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#1359: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:326:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#1359: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:326:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1360: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:327:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#1360: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:327:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1360: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:327:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#1378: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:345:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#1378: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:345:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1378: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:345:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: spaces required around that ':' (ctx:ExV)
#1379: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:346:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#1379: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:346:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1379: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:346:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#1380: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:347:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#1380: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:347:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#1398: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:365:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#1404: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:371:
+  f_t *fun[] = {&P0,&P1,&P2};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#1404: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:371:
+  f_t *fun[] = {&P0,&P1,&P2};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#1404: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:371:
+  f_t *fun[] = {&P0,&P1,&P2};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#1404: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:371:
+  f_t *fun[] = {&P0,&P1,&P2};
                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#1410: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:377:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1416: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:383:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#1418: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:385:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#1422: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:389:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#1422: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:389:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#1422: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:389:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#1422: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:389:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#1424: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:391:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1424: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:391:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#1424: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:391:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#1424: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:391:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1425: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:392:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#1425: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:392:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1426: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:393:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#1426: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:393:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#1426: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:393:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1428: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:395:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1428: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:395:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#1428: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:395:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#1428: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:395:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1429: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:396:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#1429: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:396:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#1433: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:400:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#1433: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:400:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

WARNING: line over 80 characters
#1441: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:408:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x3_i,_out_2_x0_i,_out_2_x3_i));

ERROR: space required after that ',' (ctx:VxV)
#1441: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:408:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x3_i,_out_2_x0_i,_out_2_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1441: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:408:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x3_i,_out_2_x0_i,_out_2_x3_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1441: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:408:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x3_i,_out_2_x0_i,_out_2_x3_i));
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1446: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:413:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1446: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:413:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1446: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:413:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#1447: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:414:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1457: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:424:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#1458: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:425:
+  fprintf(out,"Test ARMARM02 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1459: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:426:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#1459: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:426:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1460: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:427:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1462: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:429:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1462: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:429:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#1462: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:429:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#1462: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:429:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1463: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:430:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1464: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:431:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#1464: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:431:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1464: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:431:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#1465: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:432:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0 \\/ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#1465: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:432:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0 \\/ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1465: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:432:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0 \\/ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
             ^

ERROR: space required after that ',' (ctx:VxV)
#1466: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:433:
+  fprintf(out,"Hash=331667937512d41933d43e7fe662a69e\n");
              ^

ERROR: line over 90 characters
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1469: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:436:
+  fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#1470: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:437:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#1472: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:439:
+  fprintf(out,"Time ARMARM02 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#1472: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:439:
+  fprintf(out,"Time ARMARM02 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1477: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:444:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#1477: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:444:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1477: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:444:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#1486: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:453:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#1486: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:453:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#1489: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:456:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#1489: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:456:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#1489: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:456:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#1489: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:456:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#1498: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:465:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#1498: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:465:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#1498: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:465:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#1498: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:465:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#1502: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:469:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1505: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:472:
+    log_error( "ARMARM02: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1505: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:472:
+    log_error( "ARMARM02: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1505: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:472:
+    log_error( "ARMARM02: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#1505: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:472:
+    log_error( "ARMARM02: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#1506: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:473:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#1507: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:474:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#1508: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:475:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#1508: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:475:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#1509: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:476:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#1511: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:478:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#1513: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:480:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#1517: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:484:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#1522: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:489:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#1527: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:494:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#1535: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:502:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#1535: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:502:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#1535: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:502:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#1540: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:507:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#1540: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:507:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1540: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:507:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#1542: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:509:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#1545: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:512:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#1548: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:515:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#1551: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:518:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#1554: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:521:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#1560: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:527:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#1561: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:528:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#1561: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:528:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#1568: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:535:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#1570: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:537:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM02, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#1573: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:540:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1586: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:553:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1586: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:553:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1586: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:553:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1586: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:553:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1586: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:553:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#1592: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:559:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#1593: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:560:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#1598: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:565:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#1600: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:567:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#1600: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:567:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#1600: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:567:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#1600: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:567:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#1600: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:567:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#1601: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:568:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#1601: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:568:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#1602: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:569:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#1602: FILE: tests/tcg/aarch64/litmus/ARMARM02.c:569:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#1643: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#1652: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#1652: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#1652: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#1653: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#1653: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#1657: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#1657: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1657: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#1657: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#1657: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#1661: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#1661: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:51:
+    while (*b == 0) ;

ERROR: "foo* *bar" should be "foo **bar"
#1673: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:63:
+  int* *y;

ERROR: "foo* *bar" should be "foo **bar"
#1676: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:66:
+  int* *out_1_x0;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1681: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:71:
+  int volatile *barrier;

ERROR: "foo* bar" should be "foo *bar"
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {

ERROR: open brace '{' following function declarations go on the next line
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {

ERROR: space required after that ',' (ctx:VxV)
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {
                                                          ^

ERROR: storage class should be at the beginning of the declaration
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {

ERROR: inline keyword should sit between storage class and type
#1688: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:78:
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {

ERROR: open brace '{' following function declarations go on the next line
#1692: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:82:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#1692: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:82:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#1692: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:82:
+inline static int final_ok(int cond) {

ERROR: open brace '{' following function declarations go on the next line
#1696: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:86:
+static int idx_addr(ctx_t *_a,int _i,void *v_addr) {

ERROR: space required after that ',' (ctx:VxV)
#1696: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:86:
+static int idx_addr(ctx_t *_a,int _i,void *v_addr) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1696: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:86:
+static int idx_addr(ctx_t *_a,int _i,void *v_addr) {
                                     ^

ERROR: space required after that ';' (ctx:VxV)
#1697: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:87:
+  if (v_addr == NULL) { return 0;}
                                 ^

ERROR: trailing statements should be on next line
#1697: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:87:
+  if (v_addr == NULL) { return 0;}

ERROR: braces {} are necessary for all arms of this statement
#1697: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:87:
+  if (v_addr == NULL) { return 0;}
[...]
+  else if (v_addr == (void *)&(_a->z[_i])) return 1;
[...]
+  else if (v_addr == (void *)&(_a->y[_i])) return 2;
[...]
+  else if (v_addr == (void *)&(_a->x[_i])) return 3;
[...]
+  else { fatal("ARMARM03, ???"); return -1;}
[...]

ERROR: trailing statements should be on next line
#1698: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:88:
+  else if (v_addr == (void *)&(_a->z[_i])) return 1;

ERROR: else should follow close brace '}'
#1698: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:88:
+  if (v_addr == NULL) { return 0;}
+  else if (v_addr == (void *)&(_a->z[_i])) return 1;

ERROR: braces {} are necessary for all arms of this statement
#1698: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:88:
+  else if (v_addr == (void *)&(_a->z[_i])) return 1;
[...]
+  else if (v_addr == (void *)&(_a->y[_i])) return 2;
[...]
+  else if (v_addr == (void *)&(_a->x[_i])) return 3;
[...]
+  else { fatal("ARMARM03, ???"); return -1;}
[...]

ERROR: trailing statements should be on next line
#1699: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:89:
+  else if (v_addr == (void *)&(_a->y[_i])) return 2;

ERROR: braces {} are necessary for all arms of this statement
#1699: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:89:
+  else if (v_addr == (void *)&(_a->y[_i])) return 2;
[...]
+  else if (v_addr == (void *)&(_a->x[_i])) return 3;
[...]
+  else { fatal("ARMARM03, ???"); return -1;}
[...]

ERROR: trailing statements should be on next line
#1700: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:90:
+  else if (v_addr == (void *)&(_a->x[_i])) return 3;

ERROR: braces {} are necessary for all arms of this statement
#1700: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:90:
+  else if (v_addr == (void *)&(_a->x[_i])) return 3;
[...]
+  else { fatal("ARMARM03, ???"); return -1;}
[...]

ERROR: space required after that ';' (ctx:VxV)
#1701: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:91:
+  else { fatal("ARMARM03, ???"); return -1;}
                                           ^

ERROR: trailing statements should be on next line
#1701: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:91:
+  else { fatal("ARMARM03, ???"); return -1;}

ERROR: space required after that ',' (ctx:VxV)
#1704: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:94:
+static char *pretty_addr[4] = {"0","z","y","x",};
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#1704: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:94:
+static char *pretty_addr[4] = {"0","z","y","x",};
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1704: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:94:
+static char *pretty_addr[4] = {"0","z","y","x",};
                                           ^

ERROR: do not initialise statics to 0 or NULL
#1712: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:102:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#1718: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:108:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#1721: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:111:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#1728: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:118:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#1733: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:123:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#1734: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:124:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1734: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:124:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1734: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:124:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1734: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:124:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#1737: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:127:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#1740: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:130:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1740: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:130:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#1743: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:133:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#1748: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:138:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1749: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:139:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%s; 1:X9=%i;\n",c,show ? '*' : 
':',pretty_addr[o[out_1_x0_f]],(int)o[out_1_x9_f]);
                                                                                
                ^

ERROR: open brace '{' following function declarations go on the next line
#1752: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:142:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#1754: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:144:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#1754: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:144:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1754: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:144:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1754: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:144:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#1761: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:151:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#1765: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:155:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1766: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:156:
+  _a->out_1_x9 = malloc_check(size_of_test*sizeof(*(_a->out_1_x9)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#1767: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:157:
+  _a->z = malloc_check(size_of_test*sizeof(*(_a->z)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#1768: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:158:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#1769: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:159:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#1771: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:161:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#1774: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:164:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#1784: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:174:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#1785: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:175:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1799: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:189:
+static void check_globals(ctx_t *_a) {

ERROR: "foo* *bar" should be "foo **bar"
#1801: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:191:
+  int* *y = _a->y;

ERROR: spaces required around that '-' (ctx:VxV)
#1803: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:193:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#1804: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:194:
+    if (rand_bit(&(_a->seed)) && z[_i] != -1) fatal("ARMARM03, check_globals 
failed");

ERROR: trailing statements should be on next line
#1804: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:194:
+    if (rand_bit(&(_a->seed)) && z[_i] != -1) fatal("ARMARM03, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#1804: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:194:
+    if (rand_bit(&(_a->seed)) && z[_i] != -1) fatal("ARMARM03, check_globals 
failed");
[...]

ERROR: line over 90 characters
#1805: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:195:
+    if (rand_bit(&(_a->seed)) && y[_i] != ((int *)&(_a->z[_i]))) 
fatal("ARMARM03, check_globals failed");

ERROR: trailing statements should be on next line
#1805: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:195:
+    if (rand_bit(&(_a->seed)) && y[_i] != ((int *)&(_a->z[_i]))) 
fatal("ARMARM03, check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#1805: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:195:
+    if (rand_bit(&(_a->seed)) && y[_i] != ((int *)&(_a->z[_i]))) 
fatal("ARMARM03, check_globals failed");
[...]

WARNING: line over 80 characters
#1806: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:196:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM03, check_globals 
failed");

ERROR: trailing statements should be on next line
#1806: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:196:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM03, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#1806: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:196:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM03, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#1825: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:215:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#1830: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:220:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1830: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:220:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1830: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:220:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1833: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:223:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#1837: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:227:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#1837: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:227:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1838: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:228:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#1838: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:228:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1838: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:228:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#1850: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:240:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#1851: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:241:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#1851: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:241:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#1852: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:242:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#1852: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:242:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#1860: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:250:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#1865: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:255:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#1865: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:255:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#1865: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:255:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#1868: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:258:
+  int volatile *barrier = _a->barrier;

ERROR: "foo* *bar" should be "foo **bar"
#1871: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:261:
+  int* *out_1_x0 = _a->out_1_x0;

ERROR: suspect code indent for conditional statements (4, 6)
#1874: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:264:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#1874: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:264:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#1875: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:265:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#1875: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:265:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#1875: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:265:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#1884: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:274:
+:[x9] "=&r" (out_1_x9[_i]),[x0] "=&r" (out_1_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#1884: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:274:
+:[x9] "=&r" (out_1_x9[_i]),[x0] "=&r" (out_1_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#1885: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:275:
+:[x3] "r" (&_a->y[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#1886: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:276:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#1886: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:276:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#1904: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:294:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#1910: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:300:
+  f_t *fun[] = {&P0,&P1};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#1910: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:300:
+  f_t *fun[] = {&P0,&P1};
                     ^

ERROR: spaces required around that '-' (ctx:VxV)
#1916: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:306:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#1922: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:312:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#1924: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:314:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#1928: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:318:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#1928: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:318:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#1928: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:318:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#1928: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:318:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#1930: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:320:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1930: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:320:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#1930: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:320:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#1930: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:320:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1931: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:321:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#1931: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:321:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#1932: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:322:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#1932: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:322:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#1932: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:322:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#1934: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:324:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#1934: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:324:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#1934: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:324:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#1934: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:324:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#1935: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:325:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#1935: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:325:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#1939: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:329:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int* _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#1939: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:329:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: "foo* bar" should be "foo *bar"
#1940: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:330:
+      int* _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: space required after that ',' (ctx:VxV)
#1945: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:335:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_1_x9_i,&(ctx.x[_i])));
                                             ^

ERROR: space required after that ',' (ctx:VxO)
#1945: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:335:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_1_x9_i,&(ctx.x[_i])));
                                                         ^

ERROR: space required before that '&' (ctx:OxV)
#1945: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:335:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_1_x9_i,&(ctx.x[_i])));
                                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1946: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:336:
+      o[out_1_x0_f] = idx_addr(&ctx,_i,_out_1_x0_i);
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#1946: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:336:
+      o[out_1_x0_f] = idx_addr(&ctx,_i,_out_1_x0_i);
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1948: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:338:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#1948: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:338:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1948: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:338:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#1949: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:339:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#1959: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:349:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#1960: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:350:
+  fprintf(out,"Test ARMARM03 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1961: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:351:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#1961: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:351:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#1962: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:352:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#1964: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:354:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1964: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:354:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#1964: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:354:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#1964: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:354:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#1965: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:355:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:356:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:356:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#1966: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:356:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#1967: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:357:
+  fprintf(out,"Condition ~exists (1:X0=x /\\ 1:X9=0) is %svalidated\n",cond ? 
"" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#1967: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:357:
+  fprintf(out,"Condition ~exists (1:X0=x /\\ 1:X9=0) is %svalidated\n",cond ? 
"" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1967: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:357:
+  fprintf(out,"Condition ~exists (1:X0=x /\\ 1:X9=0) is %svalidated\n",cond ? 
"" : "NOT ");
                                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#1968: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:358:
+  fprintf(out,"Hash=5576fb6a46ae70aa15a1087a51748a39\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1969: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:359:
+  fprintf(out,"Com=Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#1970: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:360:
+  fprintf(out,"Orig=PodWWPL RfeLP DpAddrdR Fre\n");
              ^

ERROR: line over 90 characters
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#1973: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:363:
+  fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#1974: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:364:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#1976: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:366:
+  fprintf(out,"Time ARMARM03 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#1976: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:366:
+  fprintf(out,"Time ARMARM03 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#1981: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:371:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#1981: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:371:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#1981: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:371:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#1990: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:380:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#1990: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:380:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#1993: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:383:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#1993: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:383:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#1993: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:383:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#1993: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:383:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#2002: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:392:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#2002: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:392:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#2002: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:392:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#2002: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:392:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#2006: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:396:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#2009: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:399:
+    log_error( "ARMARM03: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#2009: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:399:
+    log_error( "ARMARM03: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#2009: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:399:
+    log_error( "ARMARM03: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#2009: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:399:
+    log_error( "ARMARM03: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#2010: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:400:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#2011: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:401:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#2012: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:402:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#2012: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:402:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#2013: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:403:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#2015: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:405:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#2017: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:407:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#2021: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:411:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#2026: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:416:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#2031: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:421:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#2039: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:429:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#2039: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:429:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#2039: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:429:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#2044: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:434:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#2044: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:434:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2044: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:434:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#2046: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:436:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#2049: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:439:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#2052: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:442:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#2055: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:445:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#2058: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:448:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#2064: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:454:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#2065: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:455:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#2065: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:455:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#2072: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:462:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#2074: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:464:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM03, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#2077: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:467:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#2090: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:480:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#2090: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:480:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2090: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:480:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2090: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:480:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#2090: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:480:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#2096: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:486:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#2097: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:487:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#2102: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:492:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#2104: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:494:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#2104: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:494:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#2104: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:494:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#2104: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:494:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#2104: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:494:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2105: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:495:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#2105: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:495:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#2106: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:496:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#2106: FILE: tests/tcg/aarch64/litmus/ARMARM03.c:496:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#2147: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#2156: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#2156: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#2156: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#2157: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#2157: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#2161: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#2161: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2161: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#2161: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#2161: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#2165: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#2165: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2185: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:71:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#2192: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: space required after that ',' (ctx:VxV)
#2192: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2192: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                                         ^

ERROR: storage class should be at the beginning of the declaration
#2192: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: inline keyword should sit between storage class and type
#2192: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: open brace '{' following function declarations go on the next line
#2211: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:97:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#2211: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:97:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#2211: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:97:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#2221: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:107:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#2228: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:114:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#2231: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:117:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#2238: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:124:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#2243: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:129:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#2244: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2244: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#2244: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#2244: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#2247: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:133:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#2250: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#2250: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#2253: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:139:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#2258: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:144:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                 ^

ERROR: space required after that ',' (ctx:VxV)
#2259: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#2262: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:148:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#2264: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#2264: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#2264: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2264: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#2271: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:157:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#2275: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:161:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2276: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:162:
+  _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2277: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:163:
+  _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2278: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:164:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#2279: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:165:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#2281: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:167:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#2284: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:170:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#2294: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:180:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#2295: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:181:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#2309: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:195:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#2312: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:198:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#2313: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");

ERROR: trailing statements should be on next line
#2313: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#2313: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");
[...]

WARNING: line over 80 characters
#2314: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");

ERROR: trailing statements should be on next line
#2314: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#2314: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+BIS, 
check_globals failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#2333: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:219:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2338: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2338: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2338: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2341: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:227:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2345: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2345: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2346: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2346: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2346: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#2356: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:242:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#2357: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:243:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#2358: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:244:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2358: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:244:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#2366: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:252:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2371: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2371: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2371: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2374: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:260:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2379: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2379: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2380: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2380: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2380: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#2398: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#2398: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#2399: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#2399: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#2400: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:286:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2400: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:286:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#2408: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:294:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2413: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2413: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2413: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2416: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:302:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2422: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2422: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2423: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2423: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2423: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: "foo* bar" should be "foo *bar"
#2425: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:311:
+      void* trashed_x5;

ERROR: line over 90 characters
#2444: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)

ERROR: spaces required around that ':' (ctx:ExV)
#2444: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#2444: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2444: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#2444: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                                                                             ^

ERROR: spaces required around that ':' (ctx:ExV)
#2445: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#2445: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2445: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#2446: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:332:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2446: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:332:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#2464: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:350:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#2470: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#2470: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#2470: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#2470: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#2476: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:362:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#2482: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:368:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#2484: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#2488: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#2488: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#2488: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#2488: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#2490: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2490: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#2490: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#2490: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#2491: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:377:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#2491: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:377:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#2492: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#2492: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#2492: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#2494: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2494: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#2494: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#2494: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#2495: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:381:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#2495: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:381:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#2499: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:385:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#2499: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:385:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2506: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:392:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2506: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:392:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#2510: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:396:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#2510: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:396:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#2510: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:396:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#2511: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:397:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#2521: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#2522: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:408:
+  fprintf(out,"Test ARMARM04+BIS Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2523: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:409:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#2523: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:409:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#2524: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:410:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#2526: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2526: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#2526: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#2526: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#2527: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:413:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2528: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2528: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2528: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#2529: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#2529: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2529: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
  ^

ERROR: space required after that ',' (ctx:VxV)
#2530: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:416:
+  fprintf(out,"Hash=cc1a451a55f22a8237344520956968ae\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2531: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:417:
+  fprintf(out,"Com=Rf Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#2532: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:418:
+  fprintf(out,"Orig=RfeLA PodRWAP Rfe DpAddrdRPA FreAL\n");
              ^

ERROR: line over 90 characters
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                  ^

ERROR: space required before that '!' (ctx:OxV)
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2535: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:421:
+  fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                        ^

ERROR: suspect code indent for conditional statements (2, 2)
#2536: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:422:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#2538: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:424:
+  fprintf(out,"Time ARMARM04+BIS %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#2538: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:424:
+  fprintf(out,"Time ARMARM04+BIS %.2f\n",total / 1000000.0);
                                         ^

ERROR: open brace '{' following function declarations go on the next line
#2543: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#2543: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#2543: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#2552: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:438:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#2552: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:438:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#2555: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#2555: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#2555: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#2555: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#2564: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#2564: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#2564: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#2564: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#2568: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:454:
+  prm.ncpus_used = N*n_exe;
                     ^

WARNING: line over 80 characters
#2571: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:457:
+    log_error( "ARMARM04+BIS: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#2571: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:457:
+    log_error( "ARMARM04+BIS: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#2571: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:457:
+    log_error( "ARMARM04+BIS: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#2571: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:457:
+    log_error( "ARMARM04+BIS: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                                  ^

ERROR: space prohibited after that open parenthesis '('
#2571: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:457:
+    log_error( "ARMARM04+BIS: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#2572: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:458:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#2573: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:459:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#2574: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:460:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#2574: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:460:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#2575: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:461:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#2577: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:463:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#2579: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:465:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#2583: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:469:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#2588: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:474:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#2593: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:479:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#2601: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#2601: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#2601: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#2606: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#2606: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2606: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#2608: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:494:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#2611: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:497:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#2614: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:500:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#2617: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:503:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#2620: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:506:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#2626: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:512:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#2627: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:513:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#2627: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:513:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#2634: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:520:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#2636: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:522:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM04+BIS, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#2639: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:525:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#2652: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#2652: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#2652: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#2652: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#2652: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#2658: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:544:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#2659: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:545:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#2664: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:550:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#2666: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#2666: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#2666: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#2666: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#2666: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#2667: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:553:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#2667: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:553:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#2668: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:554:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#2668: FILE: tests/tcg/aarch64/litmus/ARMARM04+BIS.c:554:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#2709: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#2718: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#2718: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#2718: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#2719: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#2719: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#2723: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#2723: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2723: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#2723: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#2723: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#2727: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#2727: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2747: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:71:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#2754: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {

ERROR: space required after that ',' (ctx:VxV)
#2754: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2754: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {
                                                         ^

ERROR: storage class should be at the beginning of the declaration
#2754: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {

ERROR: inline keyword should sit between storage class and type
#2754: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {

ERROR: open brace '{' following function declarations go on the next line
#2773: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:97:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#2773: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:97:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#2773: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:97:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#2783: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:107:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#2790: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:114:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#2793: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:117:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#2800: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:124:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#2805: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:129:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#2806: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2806: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#2806: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#2806: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#2809: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:133:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#2812: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#2812: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#2815: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:139:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#2820: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:144:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                                                                                
                 ^

ERROR: space required after that ',' (ctx:VxV)
#2821: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X2=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x2_f]);
                                                                                
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#2824: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:148:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#2826: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#2826: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#2826: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#2826: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#2833: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:157:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#2837: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:161:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2838: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:162:
+  _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2839: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:163:
+  _a->out_2_x2 = malloc_check(size_of_test*sizeof(*(_a->out_2_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#2840: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:164:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#2841: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:165:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#2843: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:167:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#2846: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:170:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#2856: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:180:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#2857: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:181:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#2871: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:195:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#2874: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:198:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#2875: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");

ERROR: trailing statements should be on next line
#2875: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#2875: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");
[...]

WARNING: line over 80 characters
#2876: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");

ERROR: trailing statements should be on next line
#2876: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#2876: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+TER, 
check_globals failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#2895: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:219:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2900: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2900: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2900: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2903: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:227:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2907: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2907: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2908: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2908: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2908: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#2918: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:242:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#2919: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:243:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#2920: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:244:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2920: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:244:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#2928: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:252:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2933: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2933: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2933: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2936: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:260:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2941: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2941: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2942: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2942: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2942: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#2954: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:278:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#2954: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:278:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#2955: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:279:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#2955: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:279:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#2956: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:280:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2956: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:280:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#2964: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:288:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#2969: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:293:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#2969: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:293:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#2969: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:293:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#2972: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:296:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#2978: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:302:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#2978: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:302:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#2979: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:303:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#2979: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:303:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#2979: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:303:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#2988: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:312:
+:[x2] "=&r" (out_2_x2[_i]),[x0] "=&r" (out_2_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#2988: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:312:
+:[x2] "=&r" (out_2_x2[_i]),[x0] "=&r" (out_2_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#2989: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:313:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#2989: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:313:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#2990: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:314:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#2990: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:314:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#3008: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:332:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#3014: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:338:
+  f_t *fun[] = {&P0,&P1,&P2};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#3014: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:338:
+  f_t *fun[] = {&P0,&P1,&P2};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#3014: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:338:
+  f_t *fun[] = {&P0,&P1,&P2};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#3014: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:338:
+  f_t *fun[] = {&P0,&P1,&P2};
                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#3020: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:344:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#3026: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:350:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#3028: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:352:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#3032: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:356:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#3032: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:356:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#3032: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:356:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#3032: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:356:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#3034: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:358:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3034: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:358:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#3034: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:358:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#3034: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:358:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#3035: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:359:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#3035: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:359:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#3036: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:360:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#3036: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:360:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#3036: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:360:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#3038: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:362:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3038: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:362:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#3038: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:362:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#3038: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:362:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#3039: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:363:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#3039: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:363:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#3043: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:367:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#3043: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:367:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#3050: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:374:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x2_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3050: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:374:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x2_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3054: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:378:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#3054: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:378:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#3054: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:378:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#3055: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:379:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#3065: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:389:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#3066: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:390:
+  fprintf(out,"Test ARMARM04+TER Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3067: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:391:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#3067: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:391:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#3068: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:392:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#3070: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:394:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3070: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:394:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#3070: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:394:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#3070: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:394:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#3071: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:395:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3072: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:396:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#3072: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:396:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3072: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:396:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#3073: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:397:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#3073: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:397:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3073: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:397:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
  ^

ERROR: space required after that ',' (ctx:VxV)
#3074: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:398:
+  fprintf(out,"Hash=b4e4b307db93ea419e3d73d315f6593d\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3075: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:399:
+  fprintf(out,"Com=Rf Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3076: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:400:
+  fprintf(out,"Orig=RfeLA PodRWAP Rfe PodRRPA FreAL\n");
              ^

ERROR: line over 90 characters
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                  ^

ERROR: space required before that '!' (ctx:OxV)
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                   ^

ERROR: space required after that ',' (ctx:VxV)
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3079: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:403:
+  fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                        ^

ERROR: suspect code indent for conditional statements (2, 2)
#3080: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:404:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#3082: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:406:
+  fprintf(out,"Time ARMARM04+TER %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#3082: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:406:
+  fprintf(out,"Time ARMARM04+TER %.2f\n",total / 1000000.0);
                                         ^

ERROR: open brace '{' following function declarations go on the next line
#3087: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:411:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#3087: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:411:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#3087: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:411:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#3096: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:420:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#3096: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:420:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#3099: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:423:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#3099: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:423:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#3099: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:423:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#3099: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:423:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#3108: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:432:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#3108: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:432:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#3108: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:432:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#3108: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:432:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#3112: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:436:
+  prm.ncpus_used = N*n_exe;
                     ^

WARNING: line over 80 characters
#3115: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:439:
+    log_error( "ARMARM04+TER: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#3115: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:439:
+    log_error( "ARMARM04+TER: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#3115: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:439:
+    log_error( "ARMARM04+TER: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#3115: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:439:
+    log_error( "ARMARM04+TER: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                                  ^

ERROR: space prohibited after that open parenthesis '('
#3115: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:439:
+    log_error( "ARMARM04+TER: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#3116: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:440:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#3117: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:441:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#3118: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:442:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#3118: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:442:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#3119: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:443:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#3121: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:445:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#3123: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:447:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#3127: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:451:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#3132: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:456:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#3137: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:461:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#3145: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:469:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#3145: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:469:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#3145: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:469:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#3150: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:474:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#3150: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:474:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3150: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:474:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#3152: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:476:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#3155: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:479:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#3158: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:482:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#3161: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:485:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#3164: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:488:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#3170: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:494:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#3171: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:495:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#3171: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:495:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#3178: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:502:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#3180: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:504:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM04+TER, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#3183: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:507:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#3196: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:520:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#3196: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:520:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3196: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:520:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#3196: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:520:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#3196: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:520:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#3202: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:526:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#3203: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:527:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#3208: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:532:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#3210: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:534:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#3210: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:534:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#3210: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:534:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#3210: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:534:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#3210: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:534:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#3211: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:535:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#3211: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:535:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#3212: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:536:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#3212: FILE: tests/tcg/aarch64/litmus/ARMARM04+TER.c:536:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#3253: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#3262: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#3262: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#3262: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#3263: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#3263: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#3267: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#3267: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3267: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#3267: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#3267: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#3271: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#3271: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3291: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:71:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#3298: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: space required after that ',' (ctx:VxV)
#3298: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3298: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                                         ^

ERROR: storage class should be at the beginning of the declaration
#3298: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: inline keyword should sit between storage class and type
#3298: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: open brace '{' following function declarations go on the next line
#3317: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:97:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#3317: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:97:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#3317: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:97:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#3327: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:107:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#3334: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:114:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#3337: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:117:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#3344: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:124:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#3349: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:129:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#3350: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3350: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#3350: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#3350: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#3353: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:133:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#3356: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3356: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#3359: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:139:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#3364: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:144:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                 ^

ERROR: space required after that ',' (ctx:VxV)
#3365: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#3368: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:148:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#3370: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#3370: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#3370: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3370: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#3377: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:157:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#3381: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:161:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3382: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:162:
+  _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3383: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:163:
+  _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3384: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:164:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#3385: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:165:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#3387: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:167:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#3390: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:170:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#3400: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:180:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#3401: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:181:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#3415: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:195:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#3418: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:198:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#3419: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04, check_globals 
failed");

ERROR: trailing statements should be on next line
#3419: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#3419: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04, check_globals 
failed");
[...]

WARNING: line over 80 characters
#3420: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04, check_globals 
failed");

ERROR: trailing statements should be on next line
#3420: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#3420: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#3439: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:219:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#3444: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#3444: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#3444: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3447: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:227:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#3451: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#3451: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#3452: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#3452: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#3452: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#3462: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:242:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#3463: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:243:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#3464: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:244:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#3464: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:244:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#3472: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:252:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#3477: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#3477: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#3477: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3480: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:260:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#3485: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#3485: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#3486: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#3486: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#3486: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#3504: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#3504: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#3505: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#3505: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#3506: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:286:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#3506: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:286:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#3514: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:294:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#3519: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#3519: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#3519: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3522: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:302:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#3528: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#3528: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#3529: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#3529: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#3529: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: "foo* bar" should be "foo *bar"
#3531: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:311:
+      void* trashed_x5;

ERROR: line over 90 characters
#3550: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)

ERROR: spaces required around that ':' (ctx:ExV)
#3550: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#3550: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#3550: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#3550: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:330:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" 
(trashed_x5),[x2] "=&r" (trashed_x2)
                                                                             ^

ERROR: spaces required around that ':' (ctx:ExV)
#3551: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#3551: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#3551: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:331:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#3552: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:332:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#3552: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:332:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#3570: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:350:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#3576: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#3576: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#3576: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#3576: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:356:
+  f_t *fun[] = {&P0,&P1,&P2};
                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#3582: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:362:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#3588: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:368:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#3590: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:370:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#3594: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#3594: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#3594: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#3594: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:374:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#3596: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3596: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#3596: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#3596: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:376:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#3597: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:377:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#3597: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:377:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#3598: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#3598: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#3598: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:378:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#3600: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3600: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#3600: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#3600: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:380:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#3601: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:381:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#3601: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:381:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#3605: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:385:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#3605: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:385:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#3612: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:392:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3612: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:392:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3616: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:396:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#3616: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:396:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#3616: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:396:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#3617: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:397:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#3627: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:407:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#3628: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:408:
+  fprintf(out,"Test ARMARM04 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3629: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:409:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#3629: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:409:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#3630: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:410:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#3632: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3632: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#3632: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#3632: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:412:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#3633: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:413:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3634: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#3634: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3634: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:414:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#3635: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#3635: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3635: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:415:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
  ^

ERROR: space required after that ',' (ctx:VxV)
#3636: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:416:
+  fprintf(out,"Hash=bd6e92e9864bd5671cb7e479e9221bae\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3637: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:417:
+  fprintf(out,"Com=Rf Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#3638: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:418:
+  fprintf(out,"Orig=RfeLA PodRWAP Rfe DpAddrdRPA FreAL\n");
              ^

ERROR: line over 90 characters
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#3641: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:421:
+  fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#3642: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:422:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#3644: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:424:
+  fprintf(out,"Time ARMARM04 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#3644: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:424:
+  fprintf(out,"Time ARMARM04 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#3649: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#3649: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#3649: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:429:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#3658: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:438:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#3658: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:438:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#3661: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#3661: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#3661: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#3661: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:441:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#3670: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#3670: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#3670: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#3670: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:450:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#3674: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:454:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#3677: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:457:
+    log_error( "ARMARM04: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#3677: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:457:
+    log_error( "ARMARM04: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#3677: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:457:
+    log_error( "ARMARM04: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#3677: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:457:
+    log_error( "ARMARM04: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#3678: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:458:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#3679: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:459:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#3680: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:460:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#3680: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:460:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#3681: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:461:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#3683: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:463:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#3685: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:465:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#3689: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:469:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#3694: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:474:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#3699: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:479:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#3707: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#3707: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#3707: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:487:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#3712: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#3712: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3712: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:492:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#3714: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:494:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#3717: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:497:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#3720: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:500:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#3723: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:503:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#3726: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:506:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#3732: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:512:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#3733: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:513:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#3733: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:513:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#3740: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:520:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#3742: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:522:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM04, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#3745: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:525:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#3758: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#3758: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#3758: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#3758: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#3758: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:538:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#3764: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:544:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#3765: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:545:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#3770: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:550:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#3772: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#3772: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#3772: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#3772: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#3772: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:552:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#3773: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:553:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#3773: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:553:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#3774: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:554:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#3774: FILE: tests/tcg/aarch64/litmus/ARMARM04.c:554:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#3815: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#3824: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#3824: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#3824: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#3825: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#3825: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#3829: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#3829: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3829: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#3829: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#3829: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#3833: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#3833: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#3853: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:71:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#3860: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: space required after that ',' (ctx:VxV)
#3860: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3860: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
                                                         ^

ERROR: storage class should be at the beginning of the declaration
#3860: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: inline keyword should sit between storage class and type
#3860: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:78:
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {

ERROR: open brace '{' following function declarations go on the next line
#3879: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:97:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#3879: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:97:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#3879: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:97:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#3889: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:107:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#3896: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:114:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#3899: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:117:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#3906: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:124:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#3911: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:129:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#3912: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3912: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#3912: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#3912: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:130:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#3915: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:133:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#3918: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#3918: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:136:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#3921: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:139:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#3926: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:144:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                 ^

ERROR: space required after that ',' (ctx:VxV)
#3927: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:145:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 2:X0=%i; 2:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_1_x0_f],(int)o[out_2_x0_f],(int)o[out_2_x3_f]);
                                                                                
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#3930: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:148:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#3932: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#3932: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#3932: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#3932: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:150:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#3939: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:157:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#3943: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:161:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3944: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:162:
+  _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3945: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:163:
+  _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#3946: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:164:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#3947: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:165:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#3949: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:167:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#3952: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:170:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#3962: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:180:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#3963: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:181:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#3977: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:195:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#3980: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:198:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#3981: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM05, check_globals 
failed");

ERROR: trailing statements should be on next line
#3981: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM05, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#3981: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:199:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM05, check_globals 
failed");
[...]

WARNING: line over 80 characters
#3982: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM05, check_globals 
failed");

ERROR: trailing statements should be on next line
#3982: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM05, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#3982: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:200:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM05, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#4001: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:219:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4006: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4006: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4006: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:224:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4009: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:227:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4013: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4013: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:231:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4014: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4014: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4014: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:232:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4024: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:242:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4025: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:243:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4026: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:244:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4026: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:244:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4034: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:252:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4039: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4039: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4039: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:257:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4042: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:260:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4047: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4047: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:265:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4048: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4048: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4048: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:266:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4066: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#4066: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:284:
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#4067: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4067: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:285:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#4068: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:286:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4068: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:286:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4076: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:294:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4081: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4081: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4081: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:299:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4084: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:302:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4090: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4090: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4091: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4091: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4091: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4109: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:327:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
 ^

ERROR: space required after that ',' (ctx:VxV)
#4109: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:327:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4109: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:327:
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
                                                     ^

ERROR: spaces required around that ':' (ctx:ExV)
#4110: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:328:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4110: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:328:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                       ^

ERROR: space required after that ',' (ctx:VxV)
#4110: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:328:
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
                                   ^

ERROR: spaces required around that ':' (ctx:ExV)
#4111: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:329:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4111: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:329:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4129: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:347:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#4135: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:353:
+  f_t *fun[] = {&P0,&P1,&P2};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#4135: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:353:
+  f_t *fun[] = {&P0,&P1,&P2};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#4135: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:353:
+  f_t *fun[] = {&P0,&P1,&P2};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#4135: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:353:
+  f_t *fun[] = {&P0,&P1,&P2};
                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#4141: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:359:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#4147: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:365:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#4149: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:367:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#4153: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:371:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#4153: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:371:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#4153: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:371:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#4153: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:371:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#4155: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:373:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#4155: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:373:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#4155: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:373:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#4155: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:373:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#4156: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:374:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#4156: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:374:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#4157: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:375:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#4157: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:375:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#4157: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:375:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#4159: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:377:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#4159: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:377:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#4159: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:377:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#4159: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:377:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#4160: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:378:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#4160: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:378:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#4164: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:382:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#4164: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:382:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#4171: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:389:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4171: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:389:
+      cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4175: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:393:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#4175: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:393:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#4175: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:393:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#4176: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:394:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#4186: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:404:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#4187: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:405:
+  fprintf(out,"Test ARMARM05 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4188: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:406:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#4188: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:406:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#4189: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:407:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#4191: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:409:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4191: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:409:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#4191: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:409:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#4191: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:409:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#4192: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:410:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4193: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:411:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#4193: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:411:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#4193: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:411:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#4194: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:412:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#4194: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:412:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4194: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:412:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
  ^

ERROR: space required after that ',' (ctx:VxV)
#4195: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:413:
+  fprintf(out,"Hash=87598a116e95069f91ea38314a500157\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4196: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:414:
+  fprintf(out,"Com=Rf Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4197: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:415:
+  fprintf(out,"Orig=Rfe PodRWPL RfeLP DpAddrdR Fre\n");
              ^

ERROR: line over 90 characters
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#4200: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:418:
+  fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#4201: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:419:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#4203: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:421:
+  fprintf(out,"Time ARMARM05 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#4203: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:421:
+  fprintf(out,"Time ARMARM05 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#4208: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:426:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#4208: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:426:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#4208: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:426:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#4217: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:435:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#4217: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:435:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#4220: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:438:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#4220: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:438:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#4220: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:438:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#4220: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:438:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#4229: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:447:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#4229: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:447:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#4229: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:447:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#4229: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:447:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#4233: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:451:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#4236: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:454:
+    log_error( "ARMARM05: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#4236: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:454:
+    log_error( "ARMARM05: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#4236: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:454:
+    log_error( "ARMARM05: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#4236: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:454:
+    log_error( "ARMARM05: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#4237: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:455:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#4238: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:456:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#4239: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:457:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#4239: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:457:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#4240: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:458:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#4242: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:460:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#4244: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:462:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#4248: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:466:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#4253: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:471:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#4258: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:476:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#4266: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:484:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#4266: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:484:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#4266: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:484:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#4271: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:489:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#4271: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:489:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4271: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:489:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#4273: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:491:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#4276: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:494:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#4279: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:497:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#4282: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:500:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#4285: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:503:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#4291: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:509:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#4292: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:510:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#4292: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:510:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#4299: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:517:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#4301: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:519:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM05, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#4304: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:522:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#4317: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:535:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#4317: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:535:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4317: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:535:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#4317: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:535:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#4317: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:535:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#4323: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:541:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#4324: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:542:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#4329: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:547:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#4331: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:549:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#4331: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:549:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#4331: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:549:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#4331: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:549:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#4331: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:549:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#4332: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:550:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#4332: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:550:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#4333: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:551:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#4333: FILE: tests/tcg/aarch64/litmus/ARMARM05.c:551:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#4374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#4383: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#4383: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#4383: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#4384: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#4384: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#4388: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#4388: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4388: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#4388: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#4388: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#4392: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#4392: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4413: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:72:
+  int volatile *barrier;

WARNING: line over 80 characters
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: space required after that ',' (ctx:VxV)
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                                       ^

ERROR: storage class should be at the beginning of the declaration
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: inline keyword should sit between storage class and type
#4420: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#4444: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:103:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#4444: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:103:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#4444: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:103:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#4454: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:113:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#4462: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:121:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#4465: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:124:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#4472: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:131:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#4477: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:136:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#4478: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4478: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#4478: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#4478: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#4481: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:140:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#4484: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4484: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#4487: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:146:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#4492: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:151:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
       ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                          ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4493: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                                                ^

ERROR: open brace '{' following function declarations go on the next line
#4496: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:155:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#4498: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#4498: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#4498: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#4498: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#4505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:164:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#4509: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:168:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#4510: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:169:
+  _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#4511: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:170:
+  _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#4512: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:171:
+  _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#4513: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:172:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#4514: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:173:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#4516: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:175:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#4519: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:178:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#4530: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:189:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#4531: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:190:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#4546: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:205:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#4549: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:208:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: line over 90 characters
#4550: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");

ERROR: trailing statements should be on next line
#4550: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#4550: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");
[...]

ERROR: line over 90 characters
#4551: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");

ERROR: trailing statements should be on next line
#4551: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#4551: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AA, 
check_globals failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#4570: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:229:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4575: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4575: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4575: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4578: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:237:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4582: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4582: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4583: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4583: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4583: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4593: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:252:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4594: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:253:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4595: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:254:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4595: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:254:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4603: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:262:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4608: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4608: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4608: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4611: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:270:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4617: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4617: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4618: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4618: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4618: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4627: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4627: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#4628: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4628: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#4629: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:288:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4629: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:288:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4637: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:296:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4642: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4642: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4642: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4645: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:304:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4649: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4649: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4650: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4650: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4650: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4660: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:319:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4661: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:320:
+:[x1] "r" (&_a->y[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#4662: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:321:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4662: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:321:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4670: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:329:
+static void *P3(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#4675: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#4675: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#4675: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4678: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:337:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#4684: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#4684: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#4685: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#4685: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#4685: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#4694: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4694: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#4695: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#4695: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#4696: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:355:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#4696: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:355:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#4714: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:373:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                         ^

ERROR: space required after that ',' (ctx:VxO)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                            ^

ERROR: space required before that '&' (ctx:OxV)
#4720: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                             ^

ERROR: spaces required around that '-' (ctx:VxV)
#4726: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:385:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#4732: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:391:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#4734: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#4738: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#4738: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#4738: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#4738: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#4740: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#4740: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#4740: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#4740: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#4741: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#4741: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#4742: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#4742: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#4742: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#4744: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#4744: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#4744: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#4744: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#4745: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#4745: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#4749: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#4749: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

WARNING: line over 80 characters
#4757: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));

ERROR: space required after that ',' (ctx:VxV)
#4757: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#4757: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4757: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#4762: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:421:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#4762: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:421:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#4762: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:421:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#4763: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:422:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#4773: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#4774: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:433:
+  fprintf(out,"Test ARMARM06+AP+AA Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4775: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#4775: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#4776: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:435:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#4778: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4778: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#4778: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#4778: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#4779: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:438:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4780: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#4780: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#4780: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#4781: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#4781: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4781: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
             ^

ERROR: space required after that ',' (ctx:VxV)
#4782: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:441:
+  fprintf(out,"Hash=09790f7c95472c70e7c2cd1b8b1f7c97\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4783: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:442:
+  fprintf(out,"Com=Rf Fr Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#4784: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:443:
+  fprintf(out,"Orig=RfeLA PodRRAP FrePL RfeLA PodRRAA FreAL\n");
              ^

ERROR: line over 90 characters
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                    ^

ERROR: space required before that '!' (ctx:OxV)
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#4787: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                          ^

ERROR: suspect code indent for conditional statements (2, 2)
#4788: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:447:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#4790: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:449:
+  fprintf(out,"Time ARMARM06+AP+AA %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#4790: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:449:
+  fprintf(out,"Time ARMARM06+AP+AA %.2f\n",total / 1000000.0);
                                           ^

ERROR: open brace '{' following function declarations go on the next line
#4795: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#4795: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#4795: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#4804: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:463:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#4804: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:463:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#4807: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#4807: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#4807: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#4807: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#4816: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#4816: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#4816: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#4816: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#4820: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:479:
+  prm.ncpus_used = N*n_exe;
                     ^

WARNING: line over 80 characters
#4823: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:482:
+    log_error( "ARMARM06+AP+AA: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#4823: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:482:
+    log_error( "ARMARM06+AP+AA: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#4823: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:482:
+    log_error( "ARMARM06+AP+AA: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#4823: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:482:
+    log_error( "ARMARM06+AP+AA: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                                    ^

ERROR: space prohibited after that open parenthesis '('
#4823: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:482:
+    log_error( "ARMARM06+AP+AA: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#4824: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:483:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#4825: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:484:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#4826: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:485:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#4826: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:485:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#4827: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:486:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#4829: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:488:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#4831: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:490:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#4835: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:494:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#4840: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:499:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#4845: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:504:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#4853: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#4853: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#4853: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#4858: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#4858: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4858: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#4860: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:519:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#4863: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:522:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#4866: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:525:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#4869: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:528:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#4872: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:531:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#4878: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:537:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#4879: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:538:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#4879: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:538:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#4886: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:545:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#4888: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:547:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM06+AP+AA, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#4891: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:550:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#4904: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#4904: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#4904: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#4904: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#4904: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#4910: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:569:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#4911: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:570:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#4916: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:575:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#4918: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#4918: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#4918: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#4918: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#4918: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#4919: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#4919: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#4920: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#4920: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#4961: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#4970: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#4970: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#4970: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#4971: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#4971: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#4975: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#4975: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#4975: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#4975: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#4975: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#4979: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#4979: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5000: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:72:
+  int volatile *barrier;

WARNING: line over 80 characters
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: space required after that ',' (ctx:VxV)
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                                       ^

ERROR: storage class should be at the beginning of the declaration
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: inline keyword should sit between storage class and type
#5007: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#5031: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:103:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#5031: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:103:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#5031: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:103:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#5041: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:113:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#5049: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:121:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#5052: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:124:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#5059: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:131:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#5064: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:136:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#5065: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5065: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#5065: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5065: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#5068: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:140:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#5071: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5071: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#5074: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:146:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#5079: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:151:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
       ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                          ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5080: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                                                ^

ERROR: open brace '{' following function declarations go on the next line
#5083: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:155:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#5085: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#5085: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5085: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#5085: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#5092: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:164:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#5096: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:168:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5097: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:169:
+  _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5098: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:170:
+  _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5099: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:171:
+  _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5100: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:172:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#5101: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:173:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#5103: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:175:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#5106: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:178:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#5117: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:189:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#5118: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:190:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#5133: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:205:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#5136: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:208:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: line over 90 characters
#5137: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");

ERROR: trailing statements should be on next line
#5137: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#5137: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");
[...]

ERROR: line over 90 characters
#5138: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");

ERROR: trailing statements should be on next line
#5138: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");

ERROR: braces {} are necessary for all arms of this statement
#5138: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AP, 
check_globals failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#5157: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:229:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5162: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5162: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5162: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5165: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:237:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5169: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5169: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5170: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5170: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5170: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5180: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:252:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5181: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:253:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5182: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:254:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5182: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:254:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5190: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:262:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5195: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5195: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5195: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5198: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:270:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5204: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5204: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5205: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5205: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5205: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5214: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5214: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#5215: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5215: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#5216: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:288:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5216: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:288:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5224: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:296:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5229: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5229: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5229: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5232: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:304:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5236: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5236: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5237: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5237: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5237: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5247: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:319:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5248: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:320:
+:[x1] "r" (&_a->y[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5249: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:321:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5249: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:321:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5257: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:329:
+static void *P3(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5262: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5262: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5262: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5265: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:337:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5271: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5271: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5272: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5272: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5272: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5281: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5281: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#5282: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5282: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#5283: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:355:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5283: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:355:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5301: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:373:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                         ^

ERROR: space required after that ',' (ctx:VxO)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                            ^

ERROR: space required before that '&' (ctx:OxV)
#5307: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                             ^

ERROR: spaces required around that '-' (ctx:VxV)
#5313: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:385:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#5319: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:391:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#5321: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#5325: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#5325: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#5325: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#5325: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#5327: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5327: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#5327: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#5327: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#5328: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#5328: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#5329: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#5329: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#5329: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5331: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#5331: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#5331: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#5331: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#5332: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#5332: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#5336: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#5336: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

WARNING: line over 80 characters
#5344: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));

ERROR: space required after that ',' (ctx:VxV)
#5344: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5344: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5344: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5349: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:421:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#5349: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:421:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#5349: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:421:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#5350: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:422:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5360: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#5361: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:433:
+  fprintf(out,"Test ARMARM06+AP+AP Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5362: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#5362: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#5363: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:435:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#5365: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5365: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#5365: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#5365: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#5366: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:438:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5367: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#5367: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5367: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#5368: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#5368: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5368: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
             ^

ERROR: space required after that ',' (ctx:VxV)
#5369: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:441:
+  fprintf(out,"Hash=73c88d83e9bc423599f9750ed7d77ac2\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5370: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:442:
+  fprintf(out,"Com=Rf Fr Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5371: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:443:
+  fprintf(out,"Orig=RfeLA PodRRAP FrePL RfeLA PodRRAP FrePL\n");
              ^

ERROR: line over 90 characters
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                    ^

ERROR: space required before that '!' (ctx:OxV)
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#5374: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:446:
+  fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true 
? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                          ^

ERROR: suspect code indent for conditional statements (2, 2)
#5375: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:447:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#5377: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:449:
+  fprintf(out,"Time ARMARM06+AP+AP %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#5377: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:449:
+  fprintf(out,"Time ARMARM06+AP+AP %.2f\n",total / 1000000.0);
                                           ^

ERROR: open brace '{' following function declarations go on the next line
#5382: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#5382: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#5382: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#5391: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:463:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#5391: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:463:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#5394: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#5394: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#5394: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#5394: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#5403: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#5403: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#5403: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#5403: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#5407: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:479:
+  prm.ncpus_used = N*n_exe;
                     ^

WARNING: line over 80 characters
#5410: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:482:
+    log_error( "ARMARM06+AP+AP: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#5410: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:482:
+    log_error( "ARMARM06+AP+AP: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5410: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:482:
+    log_error( "ARMARM06+AP+AP: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#5410: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:482:
+    log_error( "ARMARM06+AP+AP: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                                    ^

ERROR: space prohibited after that open parenthesis '('
#5410: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:482:
+    log_error( "ARMARM06+AP+AP: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#5411: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:483:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#5412: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:484:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#5413: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:485:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#5413: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:485:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#5414: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:486:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#5416: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:488:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#5418: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:490:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#5422: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:494:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#5427: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:499:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#5432: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:504:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#5440: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#5440: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#5440: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#5445: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#5445: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#5445: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#5447: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:519:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#5450: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:522:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#5453: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:525:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#5456: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:528:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#5459: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:531:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#5465: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:537:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#5466: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:538:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#5466: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:538:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#5473: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:545:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#5475: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:547:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM06+AP+AP, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#5478: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:550:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#5491: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#5491: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#5491: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#5491: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#5491: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#5497: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:569:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#5498: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:570:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#5503: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:575:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#5505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#5505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#5505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#5505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#5505: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#5506: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#5506: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#5507: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#5507: FILE: tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#5548: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#5557: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#5557: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#5557: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#5558: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#5558: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#5562: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#5562: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5562: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#5562: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#5562: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#5566: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#5566: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5587: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:72:
+  int volatile *barrier;

WARNING: line over 80 characters
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: space required after that ',' (ctx:VxV)
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {
                                                                       ^

ERROR: storage class should be at the beginning of the declaration
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: inline keyword should sit between storage class and type
#5594: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:79:
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int 
_out_3_x2) {

ERROR: open brace '{' following function declarations go on the next line
#5618: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:103:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#5618: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:103:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#5618: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:103:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#5628: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:113:
+static const int out_1_x0_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#5636: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:121:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#5639: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:124:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#5646: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:131:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#5651: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:136:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#5652: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5652: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#5652: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5652: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:137:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#5655: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:140:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#5658: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5658: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:143:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#5661: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:146:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#5666: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:151:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
       ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                          ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5667: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:152:
+  fprintf(fhist,"%-6"PCTR"%c>1:X0=%i; 1:X2=%i; 3:X0=%i; 3:X2=%i;\n",c,show ? 
'*' : 
':',(int)o[out_1_x0_f],(int)o[out_1_x2_f],(int)o[out_3_x0_f],(int)o[out_3_x2_f]);
                                                                                
                                                                ^

ERROR: open brace '{' following function declarations go on the next line
#5670: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:155:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#5672: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#5672: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5672: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#5672: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:157:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#5679: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:164:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#5683: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:168:
+  _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5684: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:169:
+  _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5685: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:170:
+  _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5686: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:171:
+  _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#5687: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:172:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#5688: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:173:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#5690: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:175:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#5693: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:178:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#5704: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:189:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#5705: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:190:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#5720: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:205:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#5723: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:208:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

WARNING: line over 80 characters
#5724: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06, check_globals 
failed");

ERROR: trailing statements should be on next line
#5724: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#5724: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:209:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06, check_globals 
failed");
[...]

WARNING: line over 80 characters
#5725: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06, check_globals 
failed");

ERROR: trailing statements should be on next line
#5725: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#5725: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:210:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#5744: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:229:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5749: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5749: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5749: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:234:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5752: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:237:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5756: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5756: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:241:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5757: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5757: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5757: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:242:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5767: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:252:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5768: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:253:
+:[x1] "r" (&_a->x[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5769: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:254:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5769: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:254:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5777: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:262:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5782: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5782: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5782: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:267:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5785: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:270:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5791: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5791: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:276:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5792: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5792: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5792: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:277:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5801: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5801: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:286:
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#5802: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5802: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:287:
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#5803: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:288:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5803: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:288:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5811: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:296:
+static void *P2(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5816: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5816: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5816: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:301:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5819: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:304:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5823: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5823: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:308:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5824: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5824: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5824: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:309:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5834: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:319:
+:[x0] "=&r" (trashed_x0)
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5835: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:320:
+:[x1] "r" (&_a->y[_i])
 ^

ERROR: spaces required around that ':' (ctx:ExV)
#5836: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:321:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5836: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:321:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5844: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:329:
+static void *P3(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#5849: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#5849: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#5849: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:334:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#5852: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:337:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#5858: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#5858: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:343:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#5859: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#5859: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#5859: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:344:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#5868: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5868: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:353:
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#5869: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#5869: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:354:
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#5870: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:355:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#5870: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:355:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#5888: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:373:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                     ^

ERROR: space required after that ',' (ctx:VxO)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                        ^

ERROR: space required before that '&' (ctx:OxV)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                         ^

ERROR: space required after that ',' (ctx:VxO)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                            ^

ERROR: space required before that '&' (ctx:OxV)
#5894: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:379:
+  f_t *fun[] = {&P0,&P1,&P2,&P3};
                             ^

ERROR: spaces required around that '-' (ctx:VxV)
#5900: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:385:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#5906: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:391:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#5908: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:393:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#5912: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#5912: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#5912: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#5912: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:397:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#5914: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5914: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#5914: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#5914: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:399:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#5915: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#5915: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:400:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#5916: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#5916: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#5916: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:401:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5918: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#5918: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#5918: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#5918: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:403:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#5919: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#5919: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:404:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#5923: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_1_x0_i = ctx.out_1_x0[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#5923: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:408:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

WARNING: line over 80 characters
#5931: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));

ERROR: space required after that ',' (ctx:VxV)
#5931: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#5931: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5931: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:416:
+      cond = 
final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5936: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:421:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#5936: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:421:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#5936: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:421:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#5937: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:422:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#5947: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:432:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#5948: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:433:
+  fprintf(out,"Test ARMARM06 Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5949: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#5949: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:434:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#5950: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:435:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#5952: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5952: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#5952: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#5952: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:437:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#5953: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:438:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5954: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#5954: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#5954: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:439:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#5955: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#5955: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5955: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:440:
+  fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is 
%svalidated\n",cond ? "" : "NOT ");
                                                                                
             ^

ERROR: space required after that ',' (ctx:VxV)
#5956: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:441:
+  fprintf(out,"Hash=e1d155e0765dad3f8a9955c387076a95\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5957: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:442:
+  fprintf(out,"Com=Rf Fr Rf Fr\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#5958: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:443:
+  fprintf(out,"Orig=RfeLA PodRRAA FreAL RfeLA PodRRAA FreAL\n");
              ^

ERROR: line over 90 characters
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                              ^

ERROR: space required before that '!' (ctx:OxV)
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                               ^

ERROR: space required after that ',' (ctx:VxV)
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#5961: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:446:
+  fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? 
"Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                                    ^

ERROR: suspect code indent for conditional statements (2, 2)
#5962: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:447:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#5964: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:449:
+  fprintf(out,"Time ARMARM06 %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#5964: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:449:
+  fprintf(out,"Time ARMARM06 %.2f\n",total / 1000000.0);
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#5969: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#5969: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#5969: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:454:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#5978: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:463:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#5978: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:463:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#5981: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#5981: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#5981: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#5981: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:466:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#5990: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#5990: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#5990: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#5990: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:475:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#5994: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:479:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#5997: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:482:
+    log_error( "ARMARM06: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#5997: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:482:
+    log_error( "ARMARM06: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#5997: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:482:
+    log_error( "ARMARM06: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                              ^

ERROR: space prohibited after that open parenthesis '('
#5997: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:482:
+    log_error( "ARMARM06: n=%i, r=%i, 
s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#5998: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:483:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#5999: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:484:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#6000: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:485:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#6000: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:485:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#6001: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:486:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#6003: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:488:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#6005: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:490:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#6009: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:494:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#6014: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:499:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#6019: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:504:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#6027: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#6027: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#6027: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:512:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#6032: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#6032: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#6032: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:517:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#6034: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:519:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#6037: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:522:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#6040: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:525:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#6043: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:528:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#6046: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:531:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#6052: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:537:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#6053: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:538:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#6053: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:538:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#6060: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:545:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#6062: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:547:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("ARMARM06, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#6065: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:550:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#6078: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#6078: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#6078: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#6078: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#6078: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:563:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#6084: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:569:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#6085: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:570:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#6090: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:575:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#6092: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#6092: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#6092: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#6092: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#6092: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:577:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#6093: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#6093: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:578:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#6094: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#6094: FILE: tests/tcg/aarch64/litmus/ARMARM06.c:579:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: space required after that ',' (ctx:VxV)
#6135: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:33:
+  int size_of_test,max_run;
                   ^

ERROR: open brace '{' following function declarations go on the next line
#6144: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:42:
+inline static void mbar(void) {

ERROR: storage class should be at the beginning of the declaration
#6144: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:42:
+inline static void mbar(void) {

ERROR: inline keyword should sit between storage class and type
#6144: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:42:
+inline static void mbar(void) {

ERROR: spaces required around that '::' (ctx:WxO)
#6145: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                              ^

ERROR: spaces required around that ':' (ctx:OxW)
#6145: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:43:
+  asm __volatile__ ("dsb sy" ::: "memory");
                                ^

WARNING: line over 80 characters
#6149: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: open brace '{' following function declarations go on the next line
#6149: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#6149: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: storage class should be at the beginning of the declaration
#6149: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: inline keyword should sit between storage class and type
#6149: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:47:
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile 
*b) {

ERROR: trailing statements should be on next line
#6153: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:51:
+    while (*b == 0) ;

ERROR: braces {} are necessary even for single statement blocks
#6153: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:51:
+    while (*b == 0) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#6172: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:70:
+  int volatile *barrier;

ERROR: open brace '{' following function declarations go on the next line
#6179: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:77:
+inline static int final_cond(int _out_0_x3,int _out_1_x3) {

ERROR: space required after that ',' (ctx:VxV)
#6179: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:77:
+inline static int final_cond(int _out_0_x3,int _out_1_x3) {
                                           ^

ERROR: storage class should be at the beginning of the declaration
#6179: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:77:
+inline static int final_cond(int _out_0_x3,int _out_1_x3) {

ERROR: inline keyword should sit between storage class and type
#6179: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:77:
+inline static int final_cond(int _out_0_x3,int _out_1_x3) {

ERROR: open brace '{' following function declarations go on the next line
#6193: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: storage class should be at the beginning of the declaration
#6193: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: inline keyword should sit between storage class and type
#6193: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:91:
+inline static int final_ok(int cond) {

ERROR: do not initialise statics to 0 or NULL
#6203: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:101:
+static const int out_0_x3_f = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#6209: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:107:
+  count_t n_pos,n_neg ;
                ^

ERROR: open brace '{' following function declarations go on the next line
#6212: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:110:
+static hist_t *alloc_hist(void) {

ERROR: open brace '{' following function declarations go on the next line
#6219: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:117:
+static void free_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#6224: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:122:
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {

ERROR: space required after that ',' (ctx:VxV)
#6225: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#6225: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#6225: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#6225: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:123:
+  h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
                                                       ^

ERROR: open brace '{' following function declarations go on the next line
#6228: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:126:
+static void merge_hists(hist_t *h0, hist_t *h1) {

ERROR: space required after that ',' (ctx:VxV)
#6231: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#6231: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:129:
+  h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
                                                      ^

ERROR: open brace '{' following function declarations go on the next line
#6234: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:132:
+static count_t sum_hist(hist_t *h) {

ERROR: open brace '{' following function declarations go on the next line
#6239: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:137:
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {

ERROR: line over 90 characters
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);

ERROR: space required after that ',' (ctx:VxV)
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);
                ^

ERROR: space required after that ',' (ctx:VxV)
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#6240: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:138:
+  fprintf(fhist,"%-6"PCTR"%c>0:X3=%i; 1:X3=%i;\n",c,show ? '*' : 
':',(int)o[out_0_x3_f],(int)o[out_1_x3_f]);
                                                                                
        ^

ERROR: open brace '{' following function declarations go on the next line
#6243: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:141:
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {

ERROR: space required after that ',' (ctx:VxV)
#6245: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                  ^

ERROR: space required after that ',' (ctx:VxV)
#6245: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#6245: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#6245: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:143:
+  dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
                                                   ^

ERROR: open brace '{' following function declarations go on the next line
#6252: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:150:
+static void init(ctx_t *_a) {

ERROR: spaces required around that '*' (ctx:VxV)
#6256: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:154:
+  _a->out_0_x3 = malloc_check(size_of_test*sizeof(*(_a->out_0_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#6257: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:155:
+  _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
                                           ^

ERROR: spaces required around that '*' (ctx:VxV)
#6258: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:156:
+  _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#6259: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:157:
+  _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
                                    ^

ERROR: spaces required around that '*' (ctx:VxV)
#6261: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:159:
+  _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#6264: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:162:
+static void finalize(ctx_t *_a) {

ERROR: open brace '{' following function declarations go on the next line
#6273: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:171:
+static void reinit(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#6274: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:172:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#6287: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:185:
+static void check_globals(ctx_t *_a) {

ERROR: spaces required around that '-' (ctx:VxV)
#6290: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:188:
+  for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
                                     ^

ERROR: trailing statements should be on next line
#6291: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#6291: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:189:
+    if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals 
failed");
[...]

ERROR: trailing statements should be on next line
#6292: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals 
failed");

ERROR: braces {} are necessary for all arms of this statement
#6292: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:190:
+    if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals 
failed");
[...]

ERROR: open brace '{' following function declarations go on the next line
#6311: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:209:
+static void *P0(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#6316: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#6316: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#6316: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:214:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#6319: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:217:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#6324: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:222:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#6324: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:222:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#6325: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#6325: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#6325: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:223:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#6339: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:237:
+:[x3] "=&r" (out_0_x3[_i]),[x0] "=&r" (trashed_x0)
 ^

ERROR: space required after that ',' (ctx:VxV)
#6339: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:237:
+:[x3] "=&r" (out_0_x3[_i]),[x0] "=&r" (trashed_x0)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#6340: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:238:
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#6340: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:238:
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#6341: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:239:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#6341: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:239:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#6349: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:247:
+static void *P1(void *_vb) {

ERROR: space required after that ',' (ctx:VxV)
#6354: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                           ^

ERROR: space required after that ',' (ctx:VxV)
#6354: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#6354: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:252:
+  force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
                                                 ^

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#6357: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:255:
+  int volatile *barrier = _a->barrier;

ERROR: suspect code indent for conditional statements (4, 6)
#6362: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:260:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+      barrier_wait(_th_id,_i,&barrier[_i]);

ERROR: spaces required around that '-' (ctx:VxV)
#6362: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:260:
+    for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#6363: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:261:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                          ^

ERROR: space required after that ',' (ctx:VxO)
#6363: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:261:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                             ^

ERROR: space required before that '&' (ctx:OxV)
#6363: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:261:
+      barrier_wait(_th_id,_i,&barrier[_i]);
                              ^

ERROR: spaces required around that ':' (ctx:ExV)
#6377: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:275:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (trashed_x0)
 ^

ERROR: space required after that ',' (ctx:VxV)
#6377: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:275:
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (trashed_x0)
                           ^

ERROR: spaces required around that ':' (ctx:ExV)
#6378: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:276:
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
 ^

ERROR: space required after that ',' (ctx:VxV)
#6378: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:276:
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
                       ^

ERROR: spaces required around that ':' (ctx:ExV)
#6379: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:277:
+:"cc","memory"
 ^

ERROR: space required after that ',' (ctx:VxV)
#6379: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:277:
+:"cc","memory"
      ^

ERROR: open brace '{' following function declarations go on the next line
#6397: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:295:
+static void *zyva(void *_va) {

ERROR: space required after that ',' (ctx:VxO)
#6403: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:301:
+  f_t *fun[] = {&P0,&P1};
                    ^

ERROR: space required before that '&' (ctx:OxV)
#6403: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:301:
+  f_t *fun[] = {&P0,&P1};
                     ^

ERROR: spaces required around that '-' (ctx:VxV)
#6409: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:307:
+  for (int _p = N-1 ; _p >= 0 ; _p--) {
                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#6415: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:313:
+    if (_b->aff_mode == aff_random) {
+      pb_wait(_a->p_barrier);

WARNING: line over 80 characters
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: space required after that ',' (ctx:VxV)
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                    ^

ERROR: space required after that ',' (ctx:VxV)
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
                                                                            ^

ERROR: trailing statements should be on next line
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);

ERROR: braces {} are necessary for all arms of this statement
#6417: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:315:
+      if (_a->z_id == 0) 
perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
[...]

ERROR: spaces required around that '>' (ctx:VxV)
#6421: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:319:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#6421: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:319:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
                                      ^

ERROR: trailing statements should be on next line
#6421: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:319:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);

ERROR: braces {} are necessary for all arms of this statement
#6421: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:319:
+    if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
[...]

ERROR: space required after that ',' (ctx:VxV)
#6423: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:321:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#6423: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:321:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
                                               ^

ERROR: trailing statements should be on next line
#6423: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:321:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);

ERROR: braces {} are necessary for all arms of this statement
#6423: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:321:
+    if (_b->do_change) perm_funs(&ctx.seed,fun,N);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#6424: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:322:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      launch(&thread[_p],fun[_p],&parg[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#6424: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:322:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: space required after that ',' (ctx:VxV)
#6425: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:323:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                         ^

ERROR: space required after that ',' (ctx:VxO)
#6425: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:323:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                 ^

ERROR: space required before that '&' (ctx:OxV)
#6425: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:323:
+      launch(&thread[_p],fun[_p],&parg[_p]);
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#6427: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:325:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                              ^

ERROR: space required after that ',' (ctx:VxV)
#6427: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:325:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
                                                     ^

ERROR: trailing statements should be on next line
#6427: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:325:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);

ERROR: braces {} are necessary for all arms of this statement
#6427: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:325:
+    if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#6428: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:326:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
+      join(&thread[_p]);

ERROR: spaces required around that '-' (ctx:VxV)
#6428: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:326:
+    for (int _p = NT-1 ; _p >= 0 ; _p--) {
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#6432: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:330:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+      int _out_0_x3_i = ctx.out_0_x3[_i];

ERROR: spaces required around that '-' (ctx:VxV)
#6432: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:330:
+    for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#6438: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:336:
+      cond = final_ok(final_cond(_out_0_x3_i,_out_1_x3_i));
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#6441: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:339:
+      add_outcome(hist,1,o,cond);
                       ^

ERROR: space required after that ',' (ctx:VxV)
#6441: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:339:
+      add_outcome(hist,1,o,cond);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#6441: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:339:
+      add_outcome(hist,1,o,cond);
                           ^

ERROR: trailing statements should be on next line
#6442: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:340:
+      if (cond) { hist->n_pos++; } else { hist->n_neg++; }

ERROR: line over 90 characters
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: open brace '{' following function declarations go on the next line
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {

ERROR: space required after that ',' (ctx:VxV)
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                              ^

ERROR: space required after that ',' (ctx:VxV)
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                     ^

ERROR: space required after that ',' (ctx:VxV)
#6452: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:350:
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t 
p_false,tsc_t total) {
                                                                                
     ^

ERROR: space required after that ',' (ctx:VxV)
#6453: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:351:
+  fprintf(out,"Test SAL Forbidden\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#6454: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:352:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
              ^

ERROR: space required after that ',' (ctx:VxV)
#6454: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:352:
+  fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#6455: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:353:
+  just_dump_outcomes(out,hist);
                         ^

ERROR: space required after that ',' (ctx:VxV)
#6457: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:355:
+  fprintf(out,"%s\n",cond?"Ok":"No");
              ^

ERROR: space required after that ',' (ctx:VxV)
#6457: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:355:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                     ^

ERROR: spaces required around that '?' (ctx:VxV)
#6457: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:355:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                          ^

ERROR: spaces required around that ':' (ctx:VxV)
#6457: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:355:
+  fprintf(out,"%s\n",cond?"Ok":"No");
                               ^

ERROR: space required after that ',' (ctx:VxV)
#6458: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:356:
+  fprintf(out,"\nWitnesses\n");
              ^

ERROR: space required after that ',' (ctx:VxV)
#6459: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:357:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
              ^

ERROR: space required after that ',' (ctx:VxV)
#6459: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:357:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#6459: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:357:
+  fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
                                                                   ^

ERROR: line over 90 characters
#6460: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:358:
+  fprintf(out,"Condition ~exists (0:X3=0 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");

ERROR: space required after that ',' (ctx:VxV)
#6460: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:358:
+  fprintf(out,"Condition ~exists (0:X3=0 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");
              ^

ERROR: space required after that ',' (ctx:VxV)
#6460: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:358:
+  fprintf(out,"Condition ~exists (0:X3=0 /\\ 1:X3=0) is %svalidated\n",cond ? 
"" : "NOT ");
                                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#6461: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:359:
+  fprintf(out,"Hash=8d89ac48ecfc60bb2f37937f74cbba0d\n");
              ^

ERROR: line over 90 characters
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);

ERROR: space required after that ',' (ctx:VxV)
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
              ^

ERROR: space required after that ',' (ctx:VxO)
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                         ^

ERROR: space required before that '!' (ctx:OxV)
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                          ^

ERROR: space required after that ',' (ctx:VxV)
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#6464: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:362:
+  fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" 
: !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
                                                                                
                                               ^

ERROR: suspect code indent for conditional statements (2, 2)
#6465: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:363:
+  if (p_true > 0) {
+  }

ERROR: space required after that ',' (ctx:VxV)
#6467: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:365:
+  fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
              ^

ERROR: space required after that ',' (ctx:VxV)
#6467: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:365:
+  fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
                                ^

ERROR: open brace '{' following function declarations go on the next line
#6472: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:370:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#6472: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:370:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                          ^

ERROR: space required after that ',' (ctx:VxV)
#6472: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:370:
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
                                               ^

ERROR: trailing statements should be on next line
#6481: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:379:
+  if (cmd->fix) prm.do_change = 0;

ERROR: braces {} are necessary for all arms of this statement
#6481: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:379:
+  if (cmd->fix) prm.do_change = 0;
[...]

ERROR: line over 90 characters
#6484: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:382:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: space required after that ',' (ctx:VxV)
#6484: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:382:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
                                                                                
  ^

ERROR: trailing statements should be on next line
#6484: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:382:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);

ERROR: braces {} are necessary for all arms of this statement
#6484: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:382:
+  if (n_avail >  cmd->aff_cpus->sz) log_error("Warning: avail=%i, 
available=%i\n",n_avail, cmd->aff_cpus->sz);
[...]

WARNING: line over 80 characters
#6493: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:391:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;

ERROR: space required after that ',' (ctx:VxV)
#6493: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:391:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#6493: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:391:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                     ^

ERROR: spaces required around that '*' (ctx:VxV)
#6493: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:391:
+  int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : 
N*n_exe;
                                                                                
^

ERROR: spaces required around that '*' (ctx:VxV)
#6497: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:395:
+  prm.ncpus_used = N*n_exe;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#6500: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:398:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#6500: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:398:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#6500: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:398:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
                                                         ^

ERROR: space prohibited after that open parenthesis '('
#6500: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:398:
+    log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);

ERROR: space required after that ',' (ctx:VxV)
#6501: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:399:
+    log_error(", st=%i",prm.stride);
                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#6502: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:400:
+    if (cmd->aff_mode == aff_incr) {
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: space required after that ',' (ctx:VxV)
#6503: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:401:
+      log_error( ", i=%i",cmd->aff_incr);
                          ^

ERROR: space prohibited after that open parenthesis '('
#6503: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:401:
+      log_error( ", i=%i",cmd->aff_incr);

ERROR: suspect code indent for conditional statements (4, 6)
#6504: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:402:
+    } else if (cmd->aff_mode == aff_random) {
+      log_error(", +ra");

ERROR: suspect code indent for conditional statements (4, 6)
#6506: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:404:
+    } else if (cmd->aff_mode == aff_custom) {
+      log_error(", +ca");

ERROR: suspect code indent for conditional statements (4, 6)
#6508: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:406:
+    } else if (cmd->aff_mode == aff_scan) {
+      log_error(", +sa");

ERROR: space required after that ',' (ctx:VxV)
#6512: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:410:
+    cpus_dump(stderr,cmd->aff_cpus);
                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#6517: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:415:
+    for (int k = 0 ; k < aff_cpus_sz ; k++) {
+      aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];

ERROR: spaces required around that '-' (ctx:VxV)
#6522: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:420:
+  int n_th = n_exe-1;
                   ^

ERROR: spaces required around that '=' (ctx:VxV)
#6530: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:428:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
               ^

ERROR: trailing statements should be on next line
#6530: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:428:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: braces {} are necessary even for single statement blocks
#6530: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:428:
+    for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;

ERROR: spaces required around that '=' (ctx:VxV)
#6535: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:433:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                 ^

ERROR: spaces required around that '=' (ctx:VxV)
#6535: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:433:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#6535: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:433:
+  int start_scan=0, max_start=gcd(delta,all_cpus->sz);
                                        ^

ERROR: spaces required around that '=' (ctx:VxV)
#6537: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:435:
+  for (int k=0 ; k < n_exe ; k++) {
             ^

ERROR: trailing whitespace
#6540: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:438:
+    p->p_mutex = p_mutex; p->p_barrier = p_barrier; $

ERROR: suspect code indent for conditional statements (4, 6)
#6543: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:441:
+    if (cmd->aff_mode != aff_incr) {
+      aff_p += N;

ERROR: spaces required around that '=' (ctx:VxV)
#6546: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:444:
+      for (int i=0 ; i < N ; i++) {
                 ^

ERROR: suspect code indent for conditional statements (8, 10)
#6549: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:447:
+        if (next_cpu == start_scan) {
+          start_scan++ ; start_scan %= max_start;

ERROR: suspect code indent for conditional statements (4, 6)
#6555: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:453:
+    if (k < n_th) {
+      launch(&th[k],zyva,p);

ERROR: space required after that ',' (ctx:VxV)
#6556: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:454:
+      launch(&th[k],zyva,p);
                    ^

ERROR: space required after that ',' (ctx:VxV)
#6556: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:454:
+      launch(&th[k],zyva,p);
                         ^

ERROR: spaces required around that '=' (ctx:VxV)
#6563: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:461:
+  for (int k=0 ; k < n_th ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#6565: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:463:
+    if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+      fatal("SAL, sum_hist");

ERROR: space required after that ',' (ctx:VxV)
#6568: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:466:
+    merge_hists(hist,hk);
                     ^

ERROR: space required after that ',' (ctx:VxV)
#6581: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:479:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                          ^

ERROR: space required after that ',' (ctx:VxV)
#6581: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:479:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                              ^

ERROR: space required after that ',' (ctx:VxV)
#6581: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:479:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#6581: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:479:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#6581: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:479:
+  int cond = postlude(out,cmd,hist,p_true,p_false,total);
                                                  ^

ERROR: open brace '{' following function declarations go on the next line
#6587: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:485:
+int main(int argc, char **argv) {

ERROR: space required after that ',' (ctx:VxV)
#6588: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:486:
+  cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
                                                   ^

ERROR: line over 90 characters
#6593: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:491:
+  cmd_t def = { 0, NUMBER_OF_RUN, SIZE_OF_TEST, STRIDE, AVAIL, 0, 0, aff_incr, 
0, 0, AFF_INCR, def_all_cpus, NULL, -1, MAX_LOOP, NULL, NULL, -1, -1, -1, 0, 0};

ERROR: space required after that ',' (ctx:VxV)
#6595: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:493:
+  parse_cmd(argc,argv,&def,&cmd);
                 ^

ERROR: space required after that ',' (ctx:VxO)
#6595: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:493:
+  parse_cmd(argc,argv,&def,&cmd);
                      ^

ERROR: space required before that '&' (ctx:OxV)
#6595: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:493:
+  parse_cmd(argc,argv,&def,&cmd);
                       ^

ERROR: space required after that ',' (ctx:VxO)
#6595: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:493:
+  parse_cmd(argc,argv,&def,&cmd);
                           ^

ERROR: space required before that '&' (ctx:OxV)
#6595: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:493:
+  parse_cmd(argc,argv,&def,&cmd);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#6596: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:494:
+  int cond = run(&cmd,def_all_cpus,stdout);
                      ^

ERROR: space required after that ',' (ctx:VxV)
#6596: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:494:
+  int cond = run(&cmd,def_all_cpus,stdout);
                                   ^

ERROR: trailing statements should be on next line
#6597: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:495:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);

ERROR: braces {} are necessary for all arms of this statement
#6597: FILE: tests/tcg/aarch64/litmus/ARMARM07+SAL.c:495:
+  if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
[...]

ERROR: trailing whitespace
#6665: FILE: tests/tcg/aarch64/litmus/README.txt:1:
+Tests produced by litmus for architecture AArch64 on linux $

ERROR: open brace '{' following function declarations go on the next line
#6715: FILE: tests/tcg/aarch64/litmus/affinity.c:23:
+cpus_t *read_affinity(void) {

ERROR: trailing whitespace
#6719: FILE: tests/tcg/aarch64/litmus/affinity.c:27:
+  $

ERROR: trailing whitespace
#6720: FILE: tests/tcg/aarch64/litmus/affinity.c:28:
+  if (res != 0) { $

ERROR: space required after that ',' (ctx:VxV)
#6721: FILE: tests/tcg/aarch64/litmus/affinity.c:29:
+    errexit("pthread_getaffinity_np",res);
                                     ^

ERROR: spaces required around that '=' (ctx:VxV)
#6723: FILE: tests/tcg/aarch64/litmus/affinity.c:31:
+  for (int p=0 ; p <  CPU_SETSIZE ; p++) {
             ^

ERROR: space required after that ',' (ctx:VxO)
#6724: FILE: tests/tcg/aarch64/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
                    ^

ERROR: space required before that '&' (ctx:OxV)
#6724: FILE: tests/tcg/aarch64/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
                     ^

ERROR: trailing statements should be on next line
#6724: FILE: tests/tcg/aarch64/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;

ERROR: braces {} are necessary for all arms of this statement
#6724: FILE: tests/tcg/aarch64/litmus/affinity.c:32:
+    if (CPU_ISSET(p,&mask)) sz++ ;
[...]

ERROR: spaces required around that '=' (ctx:VxV)
#6728: FILE: tests/tcg/aarch64/litmus/affinity.c:36:
+  for (int p=0, *q=r->cpu ; p <  CPU_SETSIZE ; p++) {
             ^

ERROR: spaces required around that '=' (ctx:VxV)
#6728: FILE: tests/tcg/aarch64/litmus/affinity.c:36:
+  for (int p=0, *q=r->cpu ; p <  CPU_SETSIZE ; p++) {
                   ^

ERROR: space required after that ',' (ctx:VxO)
#6729: FILE: tests/tcg/aarch64/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
                    ^

ERROR: space required before that '&' (ctx:OxV)
#6729: FILE: tests/tcg/aarch64/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
                     ^

ERROR: trailing statements should be on next line
#6729: FILE: tests/tcg/aarch64/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;

ERROR: braces {} are necessary for all arms of this statement
#6729: FILE: tests/tcg/aarch64/litmus/affinity.c:37:
+    if (CPU_ISSET(p,&mask)) *q++ = p ;
[...]

ERROR: storage class should be at the beginning of the declaration
#6740: FILE: tests/tcg/aarch64/litmus/affinity.c:48:
+const static tsc_t sec = (tsc_t)1000000 ;

ERROR: "foo* bar" should be "foo *bar"
#6742: FILE: tests/tcg/aarch64/litmus/affinity.c:50:
+static void* loop(void *p)  {

ERROR: open brace '{' following function declarations go on the next line
#6742: FILE: tests/tcg/aarch64/litmus/affinity.c:50:
+static void* loop(void *p)  {

ERROR: trailing statements should be on next line
#6745: FILE: tests/tcg/aarch64/litmus/affinity.c:53:
+  while (timeofday() < max) ;

ERROR: braces {} are necessary even for single statement blocks
#6745: FILE: tests/tcg/aarch64/litmus/affinity.c:53:
+  while (timeofday() < max) ;

ERROR: open brace '{' following function declarations go on the next line
#6750: FILE: tests/tcg/aarch64/litmus/affinity.c:58:
+static void warm_up(int sz, tsc_t d) {

ERROR: trailing statements should be on next line
#6753: FILE: tests/tcg/aarch64/litmus/affinity.c:61:
+    for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;

ERROR: braces {} are necessary even for single statement blocks
#6753: FILE: tests/tcg/aarch64/litmus/affinity.c:61:
+    for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;

ERROR: trailing statements should be on next line
#6754: FILE: tests/tcg/aarch64/litmus/affinity.c:62:
+    for (int k = 0 ; k < sz ; k++) join(&th[k]) ;

ERROR: braces {} are necessary even for single statement blocks
#6754: FILE: tests/tcg/aarch64/litmus/affinity.c:62:
+    for (int k = 0 ; k < sz ; k++) join(&th[k]) ;

ERROR: open brace '{' following function declarations go on the next line
#6758: FILE: tests/tcg/aarch64/litmus/affinity.c:66:
+cpus_t *read_force_affinity(int n_avail, int verbose) {

ERROR: spaces required around that '+' (ctx:VxV)
#6763: FILE: tests/tcg/aarch64/litmus/affinity.c:71:
+    warm_up(sz+1,max) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#6763: FILE: tests/tcg/aarch64/litmus/affinity.c:71:
+    warm_up(sz+1,max) ;
                 ^

ERROR: trailing statements should be on next line
#6765: FILE: tests/tcg/aarch64/litmus/affinity.c:73:
+    if (n_avail <= r->sz) return r ;

ERROR: braces {} are necessary for all arms of this statement
#6765: FILE: tests/tcg/aarch64/litmus/affinity.c:73:
+    if (n_avail <= r->sz) return r ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#6766: FILE: tests/tcg/aarch64/litmus/affinity.c:74:
+    if (verbose) {
+      fprintf(stderr,"Read affinity: '") ;

ERROR: space required after that ',' (ctx:VxV)
#6767: FILE: tests/tcg/aarch64/litmus/affinity.c:75:
+      fprintf(stderr,"Read affinity: '") ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#6768: FILE: tests/tcg/aarch64/litmus/affinity.c:76:
+      cpus_dump(stderr,r) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#6769: FILE: tests/tcg/aarch64/litmus/affinity.c:77:
+      fprintf(stderr,"'\n") ;
                     ^

ERROR: trailing whitespace
#6782: FILE: tests/tcg/aarch64/litmus/affinity.c:90:
+ $

ERROR: open brace '{' following function declarations go on the next line
#6784: FILE: tests/tcg/aarch64/litmus/affinity.c:92:
+void write_affinity(cpus_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#6790: FILE: tests/tcg/aarch64/litmus/affinity.c:98:
+    if (p->cpu[k] >= 0) {
+      CPU_SET(p->cpu[k],&mask) ;

ERROR: space required after that ',' (ctx:VxO)
#6791: FILE: tests/tcg/aarch64/litmus/affinity.c:99:
+      CPU_SET(p->cpu[k],&mask) ;
                        ^

ERROR: space required before that '&' (ctx:OxV)
#6791: FILE: tests/tcg/aarch64/litmus/affinity.c:99:
+      CPU_SET(p->cpu[k],&mask) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#6796: FILE: tests/tcg/aarch64/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                  ^

ERROR: space required after that ',' (ctx:VxO)
#6796: FILE: tests/tcg/aarch64/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                               ^

ERROR: space required before that '&' (ctx:OxV)
#6796: FILE: tests/tcg/aarch64/litmus/affinity.c:104:
+    int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
                                                                ^

ERROR: suspect code indent for conditional statements (4, 6)
#6797: FILE: tests/tcg/aarch64/litmus/affinity.c:105:
+    if (r != 0) {
+      errexit("pthread_setaffinity_np",r) ;

ERROR: space required after that ',' (ctx:VxV)
#6798: FILE: tests/tcg/aarch64/litmus/affinity.c:106:
+      errexit("pthread_setaffinity_np",r) ;
                                       ^

ERROR: open brace '{' following function declarations go on the next line
#6804: FILE: tests/tcg/aarch64/litmus/affinity.c:112:
+void write_one_affinity(int a) {

ERROR: space required after that ',' (ctx:VxO)
#6808: FILE: tests/tcg/aarch64/litmus/affinity.c:116:
+    CPU_SET(a,&mask) ;
              ^

ERROR: space required before that '&' (ctx:OxV)
#6808: FILE: tests/tcg/aarch64/litmus/affinity.c:116:
+    CPU_SET(a,&mask) ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#6810: FILE: tests/tcg/aarch64/litmus/affinity.c:118:
+    if (r != 0) {
+      errexit("pthread_setaffinity_np",r) ;

ERROR: space required after that ',' (ctx:VxV)
#6811: FILE: tests/tcg/aarch64/litmus/affinity.c:119:
+      errexit("pthread_setaffinity_np",r) ;
                                       ^

ERROR: open brace '{' following function declarations go on the next line
#6821: FILE: tests/tcg/aarch64/litmus/affinity.c:129:
+static int get_present(void) {

ERROR: space required after that ',' (ctx:VxV)
#6822: FILE: tests/tcg/aarch64/litmus/affinity.c:130:
+  FILE *fp = fopen(present,"r") ;
                           ^

ERROR: trailing statements should be on next line
#6823: FILE: tests/tcg/aarch64/litmus/affinity.c:131:
+  if (fp == NULL) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#6823: FILE: tests/tcg/aarch64/litmus/affinity.c:131:
+  if (fp == NULL) return -1 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#6824: FILE: tests/tcg/aarch64/litmus/affinity.c:132:
+  int r1,r2 ;
         ^

ERROR: space required after that ',' (ctx:VxV)
#6825: FILE: tests/tcg/aarch64/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                    ^

ERROR: space required after that ',' (ctx:VxO)
#6825: FILE: tests/tcg/aarch64/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                              ^

ERROR: space required before that '&' (ctx:OxV)
#6825: FILE: tests/tcg/aarch64/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                               ^

ERROR: space required after that ',' (ctx:VxO)
#6825: FILE: tests/tcg/aarch64/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                                  ^

ERROR: space required before that '&' (ctx:OxV)
#6825: FILE: tests/tcg/aarch64/litmus/affinity.c:133:
+  int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
                                   ^

ERROR: trailing statements should be on next line
#6827: FILE: tests/tcg/aarch64/litmus/affinity.c:135:
+  if (n != 2) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#6827: FILE: tests/tcg/aarch64/litmus/affinity.c:135:
+  if (n != 2) return -1 ;
[...]

ERROR: spaces required around that '-' (ctx:VxV)
#6828: FILE: tests/tcg/aarch64/litmus/affinity.c:136:
+  return r2-r1+1 ;
            ^

ERROR: spaces required around that '+' (ctx:VxV)
#6828: FILE: tests/tcg/aarch64/litmus/affinity.c:136:
+  return r2-r1+1 ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#6831: FILE: tests/tcg/aarch64/litmus/affinity.c:139:
+void force_one_affinity(int a, int sz,int verbose, char *name) {

ERROR: space required after that ',' (ctx:VxV)
#6831: FILE: tests/tcg/aarch64/litmus/affinity.c:139:
+void force_one_affinity(int a, int sz,int verbose, char *name) {
                                      ^

ERROR: space required after that ',' (ctx:VxO)
#6836: FILE: tests/tcg/aarch64/litmus/affinity.c:144:
+    CPU_SET(a,&mask) ;
              ^

ERROR: space required before that '&' (ctx:OxV)
#6836: FILE: tests/tcg/aarch64/litmus/affinity.c:144:
+    CPU_SET(a,&mask) ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#6837: FILE: tests/tcg/aarch64/litmus/affinity.c:145:
+    do {
+      r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;

ERROR: suspect code indent for conditional statements (8, 10)
#6840: FILE: tests/tcg/aarch64/litmus/affinity.c:148:
+        if (verbose)
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;

ERROR: braces {} are necessary for all arms of this statement
#6840: FILE: tests/tcg/aarch64/litmus/affinity.c:148:
+        if (verbose)
[...]

ERROR: space required after that ',' (ctx:VxV)
#6841: FILE: tests/tcg/aarch64/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#6841: FILE: tests/tcg/aarch64/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                                                 ^

ERROR: space required after that ',' (ctx:VxV)
#6841: FILE: tests/tcg/aarch64/litmus/affinity.c:149:
+          fprintf(stderr,"%s: force %i failed\n",name,a) ;
                                                      ^

ERROR: suspect code indent for conditional statements (8, 10)
#6843: FILE: tests/tcg/aarch64/litmus/affinity.c:151:
+        if (verbose > 1)
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;

ERROR: braces {} are necessary for all arms of this statement
#6843: FILE: tests/tcg/aarch64/litmus/affinity.c:151:
+        if (verbose > 1)
[...]

ERROR: space required after that ',' (ctx:VxV)
#6844: FILE: tests/tcg/aarch64/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#6844: FILE: tests/tcg/aarch64/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#6844: FILE: tests/tcg/aarch64/litmus/affinity.c:152:
+          fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
                                                 ^

ERROR: spaces required around that '+' (ctx:VxV)
#6845: FILE: tests/tcg/aarch64/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;
                                  ^

ERROR: trailing statements should be on next line
#6845: FILE: tests/tcg/aarch64/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;

ERROR: braces {} are necessary for all arms of this statement
#6845: FILE: tests/tcg/aarch64/litmus/affinity.c:153:
+        if (nwarm < 0) nwarm = sz+1 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#6846: FILE: tests/tcg/aarch64/litmus/affinity.c:154:
+        warm_up(nwarm,sec/100) ;
                      ^

ERROR: spaces required around that '/' (ctx:VxV)
#6846: FILE: tests/tcg/aarch64/litmus/affinity.c:154:
+        warm_up(nwarm,sec/100) ;
                          ^

WARNING: line over 80 characters
#6906: FILE: tests/tcg/aarch64/litmus/comp.sh:9:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM00.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM00.c

ERROR: line over 90 characters
#6907: FILE: tests/tcg/aarch64/litmus/comp.sh:10:
+$GCC $GCCOPTS -S ARMARM00.c && awk -f show.awk ARMARM00.s > ARMARM00.t && 
/bin/rm ARMARM00.s

WARNING: line over 80 characters
#6908: FILE: tests/tcg/aarch64/litmus/comp.sh:11:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM01.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM01.c

ERROR: line over 90 characters
#6909: FILE: tests/tcg/aarch64/litmus/comp.sh:12:
+$GCC $GCCOPTS -S ARMARM01.c && awk -f show.awk ARMARM01.s > ARMARM01.t && 
/bin/rm ARMARM01.s

WARNING: line over 80 characters
#6910: FILE: tests/tcg/aarch64/litmus/comp.sh:13:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM02.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM02.c

ERROR: line over 90 characters
#6911: FILE: tests/tcg/aarch64/litmus/comp.sh:14:
+$GCC $GCCOPTS -S ARMARM02.c && awk -f show.awk ARMARM02.s > ARMARM02.t && 
/bin/rm ARMARM02.s

WARNING: line over 80 characters
#6912: FILE: tests/tcg/aarch64/litmus/comp.sh:15:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM03.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM03.c

ERROR: line over 90 characters
#6913: FILE: tests/tcg/aarch64/litmus/comp.sh:16:
+$GCC $GCCOPTS -S ARMARM03.c && awk -f show.awk ARMARM03.s > ARMARM03.t && 
/bin/rm ARMARM03.s

ERROR: line over 90 characters
#6914: FILE: tests/tcg/aarch64/litmus/comp.sh:17:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04+BIS.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM04+BIS.c

ERROR: line over 90 characters
#6915: FILE: tests/tcg/aarch64/litmus/comp.sh:18:
+$GCC $GCCOPTS -S ARMARM04+BIS.c && awk -f show.awk ARMARM04+BIS.s > 
ARMARM04+BIS.t && /bin/rm ARMARM04+BIS.s

WARNING: line over 80 characters
#6916: FILE: tests/tcg/aarch64/litmus/comp.sh:19:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM04.c

ERROR: line over 90 characters
#6917: FILE: tests/tcg/aarch64/litmus/comp.sh:20:
+$GCC $GCCOPTS -S ARMARM04.c && awk -f show.awk ARMARM04.s > ARMARM04.t && 
/bin/rm ARMARM04.s

ERROR: line over 90 characters
#6918: FILE: tests/tcg/aarch64/litmus/comp.sh:21:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04+TER.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM04+TER.c

ERROR: line over 90 characters
#6919: FILE: tests/tcg/aarch64/litmus/comp.sh:22:
+$GCC $GCCOPTS -S ARMARM04+TER.c && awk -f show.awk ARMARM04+TER.s > 
ARMARM04+TER.t && /bin/rm ARMARM04+TER.s

WARNING: line over 80 characters
#6920: FILE: tests/tcg/aarch64/litmus/comp.sh:23:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM05.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM05.c

ERROR: line over 90 characters
#6921: FILE: tests/tcg/aarch64/litmus/comp.sh:24:
+$GCC $GCCOPTS -S ARMARM05.c && awk -f show.awk ARMARM05.s > ARMARM05.t && 
/bin/rm ARMARM05.s

ERROR: line over 90 characters
#6922: FILE: tests/tcg/aarch64/litmus/comp.sh:25:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06+AP+AA.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM06+AP+AA.c

ERROR: line over 90 characters
#6923: FILE: tests/tcg/aarch64/litmus/comp.sh:26:
+$GCC $GCCOPTS -S ARMARM06+AP+AA.c && awk -f show.awk ARMARM06+AP+AA.s > 
ARMARM06+AP+AA.t && /bin/rm ARMARM06+AP+AA.s

ERROR: line over 90 characters
#6924: FILE: tests/tcg/aarch64/litmus/comp.sh:27:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06+AP+AP.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM06+AP+AP.c

ERROR: line over 90 characters
#6925: FILE: tests/tcg/aarch64/litmus/comp.sh:28:
+$GCC $GCCOPTS -S ARMARM06+AP+AP.c && awk -f show.awk ARMARM06+AP+AP.s > 
ARMARM06+AP+AP.t && /bin/rm ARMARM06+AP+AP.s

WARNING: line over 80 characters
#6926: FILE: tests/tcg/aarch64/litmus/comp.sh:29:
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06.exe affinity.o outs.o utils.o 
litmus_rand.o ARMARM06.c

ERROR: line over 90 characters
#6927: FILE: tests/tcg/aarch64/litmus/comp.sh:30:
+$GCC $GCCOPTS -S ARMARM06.c && awk -f show.awk ARMARM06.s > ARMARM06.t && 
/bin/rm ARMARM06.s

ERROR: open brace '{' following function declarations go on the next line
#6972: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: storage class should be at the beginning of the declaration
#6972: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: inline keyword should sit between storage class and type
#6972: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:39:
+inline static uint32_t unlocked_rand(st_t *st)  {

ERROR: open brace '{' following function declarations go on the next line
#6982: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:49:
+int rand_bit(st_t *st)  {

ERROR: trailing whitespace
#6985: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:52:
+  return r ; $

ERROR: space prohibited between function name and open parenthesis '('
#6990: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:57:
+uint32_t rand_k (uint32_t *st,uint32_t k) {

ERROR: space required after that ',' (ctx:VxV)
#6990: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:57:
+uint32_t rand_k (uint32_t *st,uint32_t k) {
                              ^

ERROR: spaces required around that '-' (ctx:VxV)
#6995: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
             ^

ERROR: spaces required around that '-' (ctx:VxV)
#6995: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
                       ^

ERROR: spaces required around that '+' (ctx:VxV)
#6995: FILE: tests/tcg/aarch64/litmus/litmus_rand.c:62:
+  } while (r-v > r_max-k+1) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#7030: FILE: tests/tcg/aarch64/litmus/litmus_rand.h:27:
+uint32_t rand_k(st_t *st,uint32_t n) ;
                         ^

ERROR: if this code is redundant consider removing it
#7062: FILE: tests/tcg/aarch64/litmus/outs.c:24:
+#if 0

ERROR: open brace '{' following function declarations go on the next line
#7063: FILE: tests/tcg/aarch64/litmus/outs.c:25:
+static void debug(int *t, int i, int j) {

ERROR: spaces required around that '=' (ctx:VxV)
#7064: FILE: tests/tcg/aarch64/litmus/outs.c:26:
+  for (int k=i ; k <= j ; k++)
             ^

ERROR: braces {} are necessary even for single statement blocks
#7064: FILE: tests/tcg/aarch64/litmus/outs.c:26:
+  for (int k=i ; k <= j ; k++)
+    fprintf(stderr,"%i",t[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#7065: FILE: tests/tcg/aarch64/litmus/outs.c:27:
+    fprintf(stderr,"%i",t[k]) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#7065: FILE: tests/tcg/aarch64/litmus/outs.c:27:
+    fprintf(stderr,"%i",t[k]) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#7066: FILE: tests/tcg/aarch64/litmus/outs.c:28:
+  fprintf(stderr,"\n") ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#7073: FILE: tests/tcg/aarch64/litmus/outs.c:35:
+static outs_t *alloc_outs(intmax_t k) {

ERROR: open brace '{' following function declarations go on the next line
#7082: FILE: tests/tcg/aarch64/litmus/outs.c:44:
+void free_outs(outs_t *p) {

ERROR: trailing statements should be on next line
#7083: FILE: tests/tcg/aarch64/litmus/outs.c:45:
+  if (p == NULL) return ;

ERROR: braces {} are necessary for all arms of this statement
#7083: FILE: tests/tcg/aarch64/litmus/outs.c:45:
+  if (p == NULL) return ;
[...]

WARNING: line over 80 characters
#7090: FILE: tests/tcg/aarch64/litmus/outs.c:52:
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, 
int show) {

ERROR: open brace '{' following function declarations go on the next line
#7090: FILE: tests/tcg/aarch64/litmus/outs.c:52:
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, 
int show) {

ERROR: suspect code indent for conditional statements (4, 6)
#7099: FILE: tests/tcg/aarch64/litmus/outs.c:61:
+    if (k[i] > p->k) {
+      q = &(p->next) ;

ERROR: suspect code indent for conditional statements (4, 6)
#7102: FILE: tests/tcg/aarch64/litmus/outs.c:64:
+    } else if (i <= 0) {
+      p->c += c ;

ERROR: suspect code indent for conditional statements (4, 6)
#7111: FILE: tests/tcg/aarch64/litmus/outs.c:73:
+    if (p == NULL || k[i] < p->k) {
+      outs_t *a = alloc_outs(k[i]) ;

ERROR: open brace '{' following function declarations go on the next line
#7120: FILE: tests/tcg/aarch64/litmus/outs.c:82:
+outs_t *add_outcome_outs(outs_t *p, intmax_t *k, int sz, count_t c, int show) {

ERROR: space required after that ',' (ctx:VxV)
#7121: FILE: tests/tcg/aarch64/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#7121: FILE: tests/tcg/aarch64/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                   ^

ERROR: spaces required around that '-' (ctx:VxV)
#7121: FILE: tests/tcg/aarch64/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#7121: FILE: tests/tcg/aarch64/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#7121: FILE: tests/tcg/aarch64/litmus/outs.c:83:
+  return loop_add_outcome_outs(p,k,sz-1,c,show) ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#7124: FILE: tests/tcg/aarch64/litmus/outs.c:86:
+count_t sum_outs(outs_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#7133: FILE: tests/tcg/aarch64/litmus/outs.c:95:
+int finals_outs(outs_t *p) {

ERROR: trailing statements should be on next line
#7136: FILE: tests/tcg/aarch64/litmus/outs.c:98:
+    if (p->c > 0) r++ ;

ERROR: braces {} are necessary for all arms of this statement
#7136: FILE: tests/tcg/aarch64/litmus/outs.c:98:
+    if (p->c > 0) r++ ;
[...]

WARNING: line over 80 characters
#7142: FILE: tests/tcg/aarch64/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {

ERROR: space prohibited between function name and open parenthesis '('
#7142: FILE: tests/tcg/aarch64/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {

ERROR: space required after that ',' (ctx:VxV)
#7142: FILE: tests/tcg/aarch64/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#7142: FILE: tests/tcg/aarch64/litmus/outs.c:104:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int 
sz) {
                                                                         ^

ERROR: spaces required around that '-' (ctx:VxV)
#7144: FILE: tests/tcg/aarch64/litmus/outs.c:106:
+    buff[sz-1] = p->k ;
            ^

ERROR: suspect code indent for conditional statements (4, 6)
#7145: FILE: tests/tcg/aarch64/litmus/outs.c:107:
+    if (p->c > 0) {
+      dout(chan,buff,p->c,p->show) ;

ERROR: space required after that ',' (ctx:VxV)
#7146: FILE: tests/tcg/aarch64/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#7146: FILE: tests/tcg/aarch64/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#7146: FILE: tests/tcg/aarch64/litmus/outs.c:108:
+      dout(chan,buff,p->c,p->show) ;
                          ^

ERROR: suspect code indent for conditional statements (4, 6)
#7147: FILE: tests/tcg/aarch64/litmus/outs.c:109:
+    } else if (p->down) {
+      dump_outs(chan,dout,p->down,buff,sz-1) ;

ERROR: space required after that ',' (ctx:VxV)
#7148: FILE: tests/tcg/aarch64/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#7148: FILE: tests/tcg/aarch64/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#7148: FILE: tests/tcg/aarch64/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#7148: FILE: tests/tcg/aarch64/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                       ^

ERROR: spaces required around that '-' (ctx:VxV)
#7148: FILE: tests/tcg/aarch64/litmus/outs.c:110:
+      dump_outs(chan,dout,p->down,buff,sz-1) ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#7154: FILE: tests/tcg/aarch64/litmus/outs.c:116:
+static outs_t *do_merge_outs(outs_t *p, outs_t *q) {

ERROR: do not use C99 // comments
#7155: FILE: tests/tcg/aarch64/litmus/outs.c:117:
+  if (q == NULL) { // Nothing to add

ERROR: trailing statements should be on next line
#7155: FILE: tests/tcg/aarch64/litmus/outs.c:117:
+  if (q == NULL) { // Nothing to add

ERROR: do not use C99 // comments
#7158: FILE: tests/tcg/aarch64/litmus/outs.c:120:
+  if (p == NULL || q->k < p->k) { // Need a cell

ERROR: trailing statements should be on next line
#7158: FILE: tests/tcg/aarch64/litmus/outs.c:120:
+  if (p == NULL || q->k < p->k) { // Need a cell

ERROR: space required after that ',' (ctx:VxV)
#7166: FILE: tests/tcg/aarch64/litmus/outs.c:128:
+    p->down = do_merge_outs(p->down,q->down) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#7167: FILE: tests/tcg/aarch64/litmus/outs.c:129:
+    p->next = do_merge_outs(p->next,q->next) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#7169: FILE: tests/tcg/aarch64/litmus/outs.c:131:
+    p->next = do_merge_outs(p->next,q) ;
                                    ^

ERROR: open brace '{' following function declarations go on the next line
#7174: FILE: tests/tcg/aarch64/litmus/outs.c:136:
+outs_t *merge_outs(outs_t *p, outs_t *q, int sz) {

ERROR: space required after that ',' (ctx:VxV)
#7175: FILE: tests/tcg/aarch64/litmus/outs.c:137:
+  return do_merge_outs(p,q) ;
                         ^

ERROR: open brace '{' following function declarations go on the next line
#7178: FILE: tests/tcg/aarch64/litmus/outs.c:140:
+int same_outs(outs_t *p,outs_t *q) {

ERROR: space required after that ',' (ctx:VxV)
#7178: FILE: tests/tcg/aarch64/litmus/outs.c:140:
+int same_outs(outs_t *p,outs_t *q) {
                        ^

ERROR: trailing statements should be on next line
#7180: FILE: tests/tcg/aarch64/litmus/outs.c:142:
+    if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#7180: FILE: tests/tcg/aarch64/litmus/outs.c:142:
+    if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#7181: FILE: tests/tcg/aarch64/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;
                           ^

ERROR: trailing statements should be on next line
#7181: FILE: tests/tcg/aarch64/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#7181: FILE: tests/tcg/aarch64/litmus/outs.c:143:
+    if (!same_outs(p->down,q->down)) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxO)
#7227: FILE: tests/tcg/aarch64/litmus/outs.h:35:
+  struct outs_t *next,*down ;
                      ^

ERROR: space required before that '*' (ctx:OxV)
#7227: FILE: tests/tcg/aarch64/litmus/outs.h:35:
+  struct outs_t *next,*down ;
                       ^

WARNING: line over 80 characters
#7238: FILE: tests/tcg/aarch64/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;

ERROR: space prohibited between function name and open parenthesis '('
#7238: FILE: tests/tcg/aarch64/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;

ERROR: space required after that ',' (ctx:VxV)
#7238: FILE: tests/tcg/aarch64/litmus/outs.h:46:
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int 
sz) ;
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#7239: FILE: tests/tcg/aarch64/litmus/outs.h:47:
+outs_t *merge_outs(outs_t *p,outs_t *q, int sz) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#7240: FILE: tests/tcg/aarch64/litmus/outs.h:48:
+int same_outs(outs_t *p,outs_t *q) ;
                        ^

ERROR: line over 90 characters
#7604: FILE: tests/tcg/aarch64/litmus/run.sh:357:
+Command line: ./litmus -exit true -o run.armarm -mach overdrive01.cfg 
aarch64.tests/HAND/ARMARM00.litmus aarch64.tests/HAND/ARMARM01.litmus 
aarch64.tests/HAND/ARMARM02.litmus aarch64.tests/HAND/ARMARM03.litmus 
aarch64.tests/HAND/ARMARM04+BIS.litmus aarch64.tests/HAND/ARMARM04.litmus 
aarch64.tests/HAND/ARMARM04+TER.litmus aarch64.tests/HAND/ARMARM05.litmus 
aarch64.tests/HAND/ARMARM06+AP+AA.litmus 
aarch64.tests/HAND/ARMARM06+AP+AP.litmus aarch64.tests/HAND/ARMARM06.litmus 
aarch64.tests/HAND/ARMARM07+SAL.litmus

ERROR: open brace '{' following function declarations go on the next line
#7671: FILE: tests/tcg/aarch64/litmus/utils.c:32:
+static void checkerrlog(void) {

ERROR: trailing statements should be on next line
#7672: FILE: tests/tcg/aarch64/litmus/utils.c:33:
+  if (!errlog) errlog = stderr ;

ERROR: braces {} are necessary for all arms of this statement
#7672: FILE: tests/tcg/aarch64/litmus/utils.c:33:
+  if (!errlog) errlog = stderr ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#7675: FILE: tests/tcg/aarch64/litmus/utils.c:36:
+void seterrlog(FILE *chan) {

ERROR: open brace '{' following function declarations go on the next line
#7679: FILE: tests/tcg/aarch64/litmus/utils.c:40:
+int log_error(const char *fmt, ...) {

ERROR: open brace '{' following function declarations go on the next line
#7690: FILE: tests/tcg/aarch64/litmus/utils.c:51:
+void fatal(char *msg) {

ERROR: space required after that ',' (ctx:VxV)
#7693: FILE: tests/tcg/aarch64/litmus/utils.c:54:
+  fprintf(stdout,"Failure: %s\n", msg) ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#7697: FILE: tests/tcg/aarch64/litmus/utils.c:58:
+void errexit(char *msg,int err) {

ERROR: space required after that ',' (ctx:VxV)
#7697: FILE: tests/tcg/aarch64/litmus/utils.c:58:
+void errexit(char *msg,int err) {
                       ^

ERROR: space required after that ',' (ctx:VxV)
#7698: FILE: tests/tcg/aarch64/litmus/utils.c:59:
+  log_error("%s: %s\n",msg,strerror(err)) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#7698: FILE: tests/tcg/aarch64/litmus/utils.c:59:
+  log_error("%s: %s\n",msg,strerror(err)) ;
                           ^

ERROR: open brace '{' following function declarations go on the next line
#7703: FILE: tests/tcg/aarch64/litmus/utils.c:64:
+void *malloc_check(size_t sz) {

ERROR: trailing statements should be on next line
#7704: FILE: tests/tcg/aarch64/litmus/utils.c:65:
+  if (sz == 0) return NULL ;

ERROR: braces {} are necessary for all arms of this statement
#7704: FILE: tests/tcg/aarch64/litmus/utils.c:65:
+  if (sz == 0) return NULL ;
[...]

ERROR: trailing statements should be on next line
#7707: FILE: tests/tcg/aarch64/litmus/utils.c:68:
+    if (!errno) errno = ENOMEM ;

ERROR: braces {} are necessary for all arms of this statement
#7707: FILE: tests/tcg/aarch64/litmus/utils.c:68:
+    if (!errno) errno = ENOMEM ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#7708: FILE: tests/tcg/aarch64/litmus/utils.c:69:
+    errexit("malloc",errno) ;
                     ^

ERROR: open brace '{' following function declarations go on the next line
#7715: FILE: tests/tcg/aarch64/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {

ERROR: space required after that ',' (ctx:VxV)
#7715: FILE: tests/tcg/aarch64/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {
                      ^

ERROR: space required after that ',' (ctx:VxV)
#7715: FILE: tests/tcg/aarch64/litmus/utils.c:76:
+void pp_ints(FILE *fp,int *p,int n) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#7717: FILE: tests/tcg/aarch64/litmus/utils.c:78:
+    fprintf(fp,"%i",p[0]) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#7717: FILE: tests/tcg/aarch64/litmus/utils.c:78:
+    fprintf(fp,"%i",p[0]) ;
                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#7718: FILE: tests/tcg/aarch64/litmus/utils.c:79:
+    for (int k = 1 ; k < n ; k++) {
+      fprintf(fp,",%i",p[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#7719: FILE: tests/tcg/aarch64/litmus/utils.c:80:
+      fprintf(fp,",%i",p[k]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#7719: FILE: tests/tcg/aarch64/litmus/utils.c:80:
+      fprintf(fp,",%i",p[k]) ;
                       ^

ERROR: open brace '{' following function declarations go on the next line
#7725: FILE: tests/tcg/aarch64/litmus/utils.c:86:
+void *do_align(void *p,size_t sz) {

ERROR: space required after that ',' (ctx:VxV)
#7725: FILE: tests/tcg/aarch64/litmus/utils.c:86:
+void *do_align(void *p,size_t sz) {
                       ^

ERROR: spaces required around that '-' (ctx:VxV)
#7727: FILE: tests/tcg/aarch64/litmus/utils.c:88:
+  x += sz-1 ;
          ^

ERROR: open brace '{' following function declarations go on the next line
#7733: FILE: tests/tcg/aarch64/litmus/utils.c:94:
+void *do_noalign(void *p,size_t sz) {

ERROR: space required after that ',' (ctx:VxV)
#7733: FILE: tests/tcg/aarch64/litmus/utils.c:94:
+void *do_noalign(void *p,size_t sz) {
                         ^

ERROR: space required after that ',' (ctx:VxV)
#7734: FILE: tests/tcg/aarch64/litmus/utils.c:95:
+  void *q = do_align(p,sz) ;
                       ^

ERROR: spaces required around that '/' (ctx:VxV)
#7735: FILE: tests/tcg/aarch64/litmus/utils.c:96:
+  void *r = q - sz/2 ;
                   ^

ERROR: spaces required around that '/' (ctx:VxV)
#7736: FILE: tests/tcg/aarch64/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;
                        ^

ERROR: trailing statements should be on next line
#7736: FILE: tests/tcg/aarch64/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;

ERROR: braces {} are necessary for all arms of this statement
#7736: FILE: tests/tcg/aarch64/litmus/utils.c:97:
+  if (r < p) r = q + sz/2 ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#7740: FILE: tests/tcg/aarch64/litmus/utils.c:101:
+void cat_file(char *path, char *msg, FILE *out) {

ERROR: space required after that ',' (ctx:VxV)
#7741: FILE: tests/tcg/aarch64/litmus/utils.c:102:
+  FILE *fp = fopen(path,"r") ;
                        ^

ERROR: trailing statements should be on next line
#7742: FILE: tests/tcg/aarch64/litmus/utils.c:103:
+  if (fp == NULL) return ;

ERROR: braces {} are necessary for all arms of this statement
#7742: FILE: tests/tcg/aarch64/litmus/utils.c:103:
+  if (fp == NULL) return ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#7743: FILE: tests/tcg/aarch64/litmus/utils.c:104:
+  fprintf(out,"%s\n",msg) ;
              ^

ERROR: space required after that ',' (ctx:VxV)
#7743: FILE: tests/tcg/aarch64/litmus/utils.c:104:
+  fprintf(out,"%s\n",msg) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#7744: FILE: tests/tcg/aarch64/litmus/utils.c:105:
+  int c,nl=1 ;
        ^

ERROR: spaces required around that '=' (ctx:VxV)
#7744: FILE: tests/tcg/aarch64/litmus/utils.c:105:
+  int c,nl=1 ;
           ^

ERROR: space required after that ',' (ctx:VxV)
#7746: FILE: tests/tcg/aarch64/litmus/utils.c:107:
+    fputc(c,out) ;
            ^

ERROR: space required after that ',' (ctx:VxV)
#7750: FILE: tests/tcg/aarch64/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;
                      ^

ERROR: trailing statements should be on next line
#7750: FILE: tests/tcg/aarch64/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;

ERROR: braces {} are necessary for all arms of this statement
#7750: FILE: tests/tcg/aarch64/litmus/utils.c:111:
+  if (!nl) fputc('\n',out) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#7757: FILE: tests/tcg/aarch64/litmus/utils.c:118:
+cpus_t *cpus_create(int sz) {

ERROR: spaces required around that '*' (ctx:VxV)
#7760: FILE: tests/tcg/aarch64/litmus/utils.c:121:
+  r->cpu = malloc_check(sizeof(r->cpu[0])*sz)  ;
                                          ^

ERROR: open brace '{' following function declarations go on the next line
#7764: FILE: tests/tcg/aarch64/litmus/utils.c:125:
+cpus_t *cpus_create_init(int sz, int t[]) {

ERROR: trailing statements should be on next line
#7766: FILE: tests/tcg/aarch64/litmus/utils.c:127:
+  for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;

ERROR: braces {} are necessary even for single statement blocks
#7766: FILE: tests/tcg/aarch64/litmus/utils.c:127:
+  for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;

ERROR: open brace '{' following function declarations go on the next line
#7770: FILE: tests/tcg/aarch64/litmus/utils.c:131:
+void cpus_free(cpus_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#7775: FILE: tests/tcg/aarch64/litmus/utils.c:136:
+void cpus_dump(FILE *fp, cpus_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#7776: FILE: tests/tcg/aarch64/litmus/utils.c:137:
+  pp_ints(fp,p->cpu,p->sz) ;
             ^

ERROR: space required after that ',' (ctx:VxV)
#7776: FILE: tests/tcg/aarch64/litmus/utils.c:137:
+  pp_ints(fp,p->cpu,p->sz) ;
                    ^

ERROR: open brace '{' following function declarations go on the next line
#7779: FILE: tests/tcg/aarch64/litmus/utils.c:140:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {

ERROR: space required after that ',' (ctx:VxV)
#7779: FILE: tests/tcg/aarch64/litmus/utils.c:140:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#7781: FILE: tests/tcg/aarch64/litmus/utils.c:142:
+    fprintf(fp,"[") ;
               ^

ERROR: space required after that ',' (ctx:VxO)
#7782: FILE: tests/tcg/aarch64/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
               ^

ERROR: space required before that '&' (ctx:OxV)
#7782: FILE: tests/tcg/aarch64/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#7782: FILE: tests/tcg/aarch64/litmus/utils.c:143:
+    pp_ints(fp,&p[k],nprocs) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#7783: FILE: tests/tcg/aarch64/litmus/utils.c:144:
+    fprintf(fp,"] {") ;
               ^

ERROR: suspect code indent for conditional statements (4, 6)
#7784: FILE: tests/tcg/aarch64/litmus/utils.c:145:
+    if (nprocs > 0) {
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;

ERROR: space required after that ',' (ctx:VxV)
#7785: FILE: tests/tcg/aarch64/litmus/utils.c:146:
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#7785: FILE: tests/tcg/aarch64/litmus/utils.c:146:
+      fprintf(fp,"%i",cm->cpu[p[k]]) ;
                      ^

ERROR: space required after that ',' (ctx:VxV)
#7787: FILE: tests/tcg/aarch64/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#7787: FILE: tests/tcg/aarch64/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                         ^

ERROR: spaces required around that '+' (ctx:VxV)
#7787: FILE: tests/tcg/aarch64/litmus/utils.c:148:
+        fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#7790: FILE: tests/tcg/aarch64/litmus/utils.c:151:
+    fprintf(fp,"}\n") ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#7799: FILE: tests/tcg/aarch64/litmus/utils.c:160:
+void ints_dump(FILE *fp, ints_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#7801: FILE: tests/tcg/aarch64/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
               ^

ERROR: space required after that ',' (ctx:VxV)
#7801: FILE: tests/tcg/aarch64/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#7801: FILE: tests/tcg/aarch64/litmus/utils.c:162:
+    fprintf(fp,"%i:%i",0,p->t[0]) ;
                         ^

ERROR: suspect code indent for conditional statements (4, 6)
#7802: FILE: tests/tcg/aarch64/litmus/utils.c:163:
+    for (int k = 1 ; k < p->sz ; k++) {
+      fprintf(fp,",%i:%i",k,p->t[k]) ;

ERROR: space required after that ',' (ctx:VxV)
#7803: FILE: tests/tcg/aarch64/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                 ^

ERROR: space required after that ',' (ctx:VxV)
#7803: FILE: tests/tcg/aarch64/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#7803: FILE: tests/tcg/aarch64/litmus/utils.c:164:
+      fprintf(fp,",%i:%i",k,p->t[k]) ;
                            ^

ERROR: open brace '{' following function declarations go on the next line
#7811: FILE: tests/tcg/aarch64/litmus/utils.c:172:
+void prefetch_dump(FILE *fp, prfdirs_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#7817: FILE: tests/tcg/aarch64/litmus/utils.c:178:
+    for (int _v = 0 ; _v < nvars ; _v++) {
+      prfdir_t dir = r[_v].dir ;

ERROR: trailing statements should be on next line
#7821: FILE: tests/tcg/aarch64/litmus/utils.c:182:
+        if (dir == flush) c = 'F' ;

ERROR: braces {} are necessary for all arms of this statement
#7821: FILE: tests/tcg/aarch64/litmus/utils.c:182:
+        if (dir == flush) c = 'F' ;
[...]
+        else if (dir == touch) c = 'T' ;
[...]
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: trailing statements should be on next line
#7822: FILE: tests/tcg/aarch64/litmus/utils.c:183:
+        else if (dir == touch) c = 'T' ;

ERROR: braces {} are necessary for all arms of this statement
#7822: FILE: tests/tcg/aarch64/litmus/utils.c:183:
+        else if (dir == touch) c = 'T' ;
[...]
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: trailing statements should be on next line
#7823: FILE: tests/tcg/aarch64/litmus/utils.c:184:
+        else if (dir == touch_store) c = 'W' ;

ERROR: braces {} are necessary for all arms of this statement
#7823: FILE: tests/tcg/aarch64/litmus/utils.c:184:
+        else if (dir == touch_store) c = 'W' ;
[...]

ERROR: suspect code indent for conditional statements (8, 10)
#7824: FILE: tests/tcg/aarch64/litmus/utils.c:185:
+        if (some) {
+          fprintf(fp,",") ;

ERROR: space required after that ',' (ctx:VxV)
#7825: FILE: tests/tcg/aarch64/litmus/utils.c:186:
+          fprintf(fp,",") ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#7829: FILE: tests/tcg/aarch64/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#7829: FILE: tests/tcg/aarch64/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#7829: FILE: tests/tcg/aarch64/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#7829: FILE: tests/tcg/aarch64/litmus/utils.c:190:
+        fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
                                            ^

ERROR: open brace '{' following function declarations go on the next line
#7835: FILE: tests/tcg/aarch64/litmus/utils.c:196:
+static void set_prefetch(prfdirs_t *p, prfdir_t d) {

ERROR: suspect code indent for conditional statements (4, 6)
#7840: FILE: tests/tcg/aarch64/litmus/utils.c:201:
+    for (int _v = 0 ; _v < nvars ; _v++) {
+      r[_v].dir = d ;

ERROR: open brace '{' following function declarations go on the next line
#7848: FILE: tests/tcg/aarch64/litmus/utils.c:209:
+int gcd(int a, int b) {

ERROR: trailing statements should be on next line
#7850: FILE: tests/tcg/aarch64/litmus/utils.c:211:
+    if (a == 0) return b ;

ERROR: braces {} are necessary for all arms of this statement
#7850: FILE: tests/tcg/aarch64/litmus/utils.c:211:
+    if (a == 0) return b ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#7860: FILE: tests/tcg/aarch64/litmus/utils.c:221:
+cpus_t *coremap_seq(int navail, int nways) {

ERROR: suspect code indent for conditional statements (4, 6)
#7865: FILE: tests/tcg/aarch64/litmus/utils.c:226:
+    for (int k = 0 ; k < nways ; k++) {
+      r->cpu[i++] = c ;

ERROR: open brace '{' following function declarations go on the next line
#7872: FILE: tests/tcg/aarch64/litmus/utils.c:233:
+cpus_t *coremap_end(int navail, int nways) {

ERROR: suspect code indent for conditional statements (4, 6)
#7877: FILE: tests/tcg/aarch64/litmus/utils.c:238:
+    for (int c = 0 ; c < ncores ; c++) {
+      r->cpu[i++] = c ;

ERROR: open brace '{' following function declarations go on the next line
#7890: FILE: tests/tcg/aarch64/litmus/utils.c:251:
+static void mapcore_free(mapcore_t *p) {

ERROR: trailing statements should be on next line
#7891: FILE: tests/tcg/aarch64/litmus/utils.c:252:
+  for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;

ERROR: braces {} are necessary even for single statement blocks
#7891: FILE: tests/tcg/aarch64/litmus/utils.c:252:
+  for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;

ERROR: if this code is redundant consider removing it
#7896: FILE: tests/tcg/aarch64/litmus/utils.c:257:
+#if 0

ERROR: open brace '{' following function declarations go on the next line
#7897: FILE: tests/tcg/aarch64/litmus/utils.c:258:
+static mapcore_t *inverse_coremap(cpus_t *p, int nways) {

ERROR: open brace '{' following function declarations go on the next line
#7914: FILE: tests/tcg/aarch64/litmus/utils.c:275:
+static int get_ncores(cpus_t *cm) {

ERROR: trailing statements should be on next line
#7917: FILE: tests/tcg/aarch64/litmus/utils.c:278:
+    if (cm->cpu[k] > r) r = cm->cpu[k] ;

ERROR: braces {} are necessary for all arms of this statement
#7917: FILE: tests/tcg/aarch64/litmus/utils.c:278:
+    if (cm->cpu[k] > r) r = cm->cpu[k] ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#7919: FILE: tests/tcg/aarch64/litmus/utils.c:280:
+  return r+1 ;
           ^

ERROR: open brace '{' following function declarations go on the next line
#7922: FILE: tests/tcg/aarch64/litmus/utils.c:283:
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {

ERROR: space required after that ',' (ctx:VxV)
#7922: FILE: tests/tcg/aarch64/litmus/utils.c:283:
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {
                                             ^

ERROR: trailing statements should be on next line
#7926: FILE: tests/tcg/aarch64/litmus/utils.c:287:
+    if (cm->cpu[p->cpu[k]] == c) sz++ ;

ERROR: braces {} are necessary for all arms of this statement
#7926: FILE: tests/tcg/aarch64/litmus/utils.c:287:
+    if (cm->cpu[p->cpu[k]] == c) sz++ ;
[...]

ERROR: trailing statements should be on next line
#7932: FILE: tests/tcg/aarch64/litmus/utils.c:293:
+    if (cm->cpu[proc] == c) r->cpu[i++] = proc ;

ERROR: braces {} are necessary for all arms of this statement
#7932: FILE: tests/tcg/aarch64/litmus/utils.c:293:
+    if (cm->cpu[proc] == c) r->cpu[i++] = proc ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#7937: FILE: tests/tcg/aarch64/litmus/utils.c:298:
+static  mapcore_t *inverse_procs(cpus_t *cm, cpus_t *p) {

ERROR: spaces required around that '*' (ctx:VxV)
#7941: FILE: tests/tcg/aarch64/litmus/utils.c:302:
+  r->core = malloc_check(sizeof(r->core[0])*ncores) ;
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#7943: FILE: tests/tcg/aarch64/litmus/utils.c:304:
+    r->core[c] = get_core_procs(cm,p,c) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#7943: FILE: tests/tcg/aarch64/litmus/utils.c:304:
+    r->core[c] = get_core_procs(cm,p,c) ;
                                     ^

ERROR: open brace '{' following function declarations go on the next line
#7948: FILE: tests/tcg/aarch64/litmus/utils.c:309:
+static int get_node_sz(int *p) {

ERROR: trailing statements should be on next line
#7950: FILE: tests/tcg/aarch64/litmus/utils.c:311:
+  while (*p++ >= 0) r++ ;

ERROR: braces {} are necessary even for single statement blocks
#7950: FILE: tests/tcg/aarch64/litmus/utils.c:311:
+  while (*p++ >= 0) r++ ;

ERROR: open brace '{' following function declarations go on the next line
#7954: FILE: tests/tcg/aarch64/litmus/utils.c:315:
+static int get_n(int **p) {

ERROR: open brace '{' following function declarations go on the next line
#7963: FILE: tests/tcg/aarch64/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {

ERROR: space required after that ',' (ctx:VxV)
#7963: FILE: tests/tcg/aarch64/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                ^

ERROR: space required after that ',' (ctx:VxV)
#7963: FILE: tests/tcg/aarch64/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#7963: FILE: tests/tcg/aarch64/litmus/utils.c:324:
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
                                              ^

ERROR: suspect code indent for conditional statements (4, 6)
#7966: FILE: tests/tcg/aarch64/litmus/utils.c:327:
+    if (op >= 0) {
+      if (d[n*p+k]) {

ERROR: spaces required around that '*' (ctx:VxV)
#7967: FILE: tests/tcg/aarch64/litmus/utils.c:328:
+      if (d[n*p+k]) {
              ^

ERROR: spaces required around that '+' (ctx:VxV)
#7967: FILE: tests/tcg/aarch64/litmus/utils.c:328:
+      if (d[n*p+k]) {
                ^

ERROR: suspect code indent for conditional statements (8, 10)
#7969: FILE: tests/tcg/aarch64/litmus/utils.c:330:
+        if (oc == c) {
+          return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#7978: FILE: tests/tcg/aarch64/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {

ERROR: space required after that ',' (ctx:VxV)
#7978: FILE: tests/tcg/aarch64/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#7978: FILE: tests/tcg/aarch64/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#7978: FILE: tests/tcg/aarch64/litmus/utils.c:339:
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                             ^

ERROR: space required after that ',' (ctx:VxO)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                               ^

ERROR: space required before that '*' (ctx:OxV)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
                                  ^

ERROR: trailing statements should be on next line
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#7980: FILE: tests/tcg/aarch64/litmus/utils.c:341:
+    if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#7986: FILE: tests/tcg/aarch64/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
          ^

ERROR: space required after that ',' (ctx:VxV)
#7986: FILE: tests/tcg/aarch64/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                   ^

ERROR: space required after that ',' (ctx:VxV)
#7986: FILE: tests/tcg/aarch64/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#7986: FILE: tests/tcg/aarch64/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#7986: FILE: tests/tcg/aarch64/litmus/utils.c:347:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#7988: FILE: tests/tcg/aarch64/litmus/utils.c:349:
+  int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                     ^

ERROR: space required after that ',' (ctx:VxV)
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                       ^

ERROR: space required after that ',' (ctx:VxV)
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
                                           ^

ERROR: trailing statements should be on next line
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;

ERROR: braces {} are necessary for all arms of this statement
#7992: FILE: tests/tcg/aarch64/litmus/utils.c:353:
+    if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
          ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                   ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                         ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#8000: FILE: tests/tcg/aarch64/litmus/utils.c:361:
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#8002: FILE: tests/tcg/aarch64/litmus/utils.c:363:
+  int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
                                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#8006: FILE: tests/tcg/aarch64/litmus/utils.c:367:
+    if (pk->sz > 0) {
+      if (found < 0) found = k ;

ERROR: trailing statements should be on next line
#8007: FILE: tests/tcg/aarch64/litmus/utils.c:368:
+      if (found < 0) found = k ;

ERROR: braces {} are necessary for all arms of this statement
#8007: FILE: tests/tcg/aarch64/litmus/utils.c:368:
+      if (found < 0) found = k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
                                  ^

ERROR: trailing statements should be on next line
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;

ERROR: braces {} are necessary for all arms of this statement
#8008: FILE: tests/tcg/aarch64/litmus/utils.c:369:
+      if (ok_one_color(cm,d,a,n,p,k)) return k ;
[...]

ERROR: trailing statements should be on next line
#8012: FILE: tests/tcg/aarch64/litmus/utils.c:373:
+  if (found < 0) fatal("Cannot allocate threads") ;

ERROR: braces {} are necessary for all arms of this statement
#8012: FILE: tests/tcg/aarch64/litmus/utils.c:373:
+  if (found < 0) fatal("Cannot allocate threads") ;
[...]

ERROR: line over 90 characters
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {

ERROR: space prohibited between function name and open parenthesis '('
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {

ERROR: space required after that ',' (ctx:VxV)
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                               ^

ERROR: space required after that ',' (ctx:VxV)
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                                ^

ERROR: space required after that ',' (ctx:VxV)
#8016: FILE: tests/tcg/aarch64/litmus/utils.c:377:
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t 
*aff_cpus,int n_exe, int *r) {
                                                                                
 ^

ERROR: space required after that ',' (ctx:VxV)
#8017: FILE: tests/tcg/aarch64/litmus/utils.c:378:
+  mapcore_t *mc = inverse_procs(cm,aff_cpus) ;
                                   ^

ERROR: spaces required around that '*' (ctx:VxV)
#8020: FILE: tests/tcg/aarch64/litmus/utils.c:381:
+  int d[n*n] ;
          ^

ERROR: spaces required around that '*' (ctx:VxV)
#8023: FILE: tests/tcg/aarch64/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;
                           ^

ERROR: trailing statements should be on next line
#8023: FILE: tests/tcg/aarch64/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;

ERROR: braces {} are necessary even for single statement blocks
#8023: FILE: tests/tcg/aarch64/litmus/utils.c:384:
+    for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;

ERROR: suspect code indent for conditional statements (4, 6)
#8024: FILE: tests/tcg/aarch64/litmus/utils.c:385:
+    while (*q >= 0) {
+      int x = *q++, y = *q++ ;

ERROR: spaces required around that '*' (ctx:VxV)
#8026: FILE: tests/tcg/aarch64/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
          ^

ERROR: spaces required around that '+' (ctx:VxV)
#8026: FILE: tests/tcg/aarch64/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
            ^

ERROR: spaces required around that '*' (ctx:VxV)
#8026: FILE: tests/tcg/aarch64/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#8026: FILE: tests/tcg/aarch64/litmus/utils.c:387:
+      d[n*x+y] = d[n*y+x] = 1 ;
                       ^

ERROR: spaces required around that '*' (ctx:VxV)
#8030: FILE: tests/tcg/aarch64/litmus/utils.c:391:
+    int *a = &r[k*n] ;
                  ^

ERROR: trailing statements should be on next line
#8032: FILE: tests/tcg/aarch64/litmus/utils.c:393:
+    for (int i = 0 ; i < n ; i++) a[i] = -1 ;

ERROR: braces {} are necessary even for single statement blocks
#8032: FILE: tests/tcg/aarch64/litmus/utils.c:393:
+    for (int i = 0 ; i < n ; i++) a[i] = -1 ;

ERROR: suspect code indent for conditional statements (4, 6)
#8033: FILE: tests/tcg/aarch64/litmus/utils.c:394:
+    for (int **q = color ; *q ; q++) {
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                            ^

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                ^

ERROR: space required after that ',' (ctx:VxO)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                  ^

ERROR: space required before that '*' (ctx:OxV)
#8034: FILE: tests/tcg/aarch64/litmus/utils.c:395:
+      int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
                                                                   ^

ERROR: suspect code indent for conditional statements (8, 10)
#8037: FILE: tests/tcg/aarch64/litmus/utils.c:398:
+        for (int *qq = *q ; *qq >= 0 ; qq++) {
+          p->sz-- ;

ERROR: suspect code indent for conditional statements (8, 10)
#8043: FILE: tests/tcg/aarch64/litmus/utils.c:404:
+        for (int *qq = *q ; *qq >= 0 ; qq++) {
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                          ^

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                           ^

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                              ^

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                ^

ERROR: space required after that ',' (ctx:VxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                  ^

ERROR: space required after that ',' (ctx:VxO)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                    ^

ERROR: space required before that '*' (ctx:OxV)
#8044: FILE: tests/tcg/aarch64/litmus/utils.c:405:
+          int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
                                                                     ^

ERROR: open brace '{' following function declarations go on the next line
#8062: FILE: tests/tcg/aarch64/litmus/utils.c:423:
+static void usage(char *prog, cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#8063: FILE: tests/tcg/aarch64/litmus/utils.c:424:
+  log_error("usage: %s (options)*\n",prog) ;
                                     ^

ERROR: line over 90 characters
#8066: FILE: tests/tcg/aarch64/litmus/utils.c:427:
+  log_error("  -a <n>  run maximal number of tests for n available processors 
(default %i)\n",d->avail) ;

ERROR: space required after that ',' (ctx:VxV)
#8066: FILE: tests/tcg/aarch64/litmus/utils.c:427:
+  log_error("  -a <n>  run maximal number of tests for n available processors 
(default %i)\n",d->avail) ;
                                                                                
              ^

ERROR: space required after that ',' (ctx:VxV)
#8068: FILE: tests/tcg/aarch64/litmus/utils.c:429:
+  log_error("  -r <n>  perform n runs (default %i)\n",d->max_run) ;
                                                      ^

ERROR: space required after that ',' (ctx:VxV)
#8070: FILE: tests/tcg/aarch64/litmus/utils.c:431:
+  log_error("  -s <n>  outcomes per run (default %i)\n",d->size_of_test) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#8072: FILE: tests/tcg/aarch64/litmus/utils.c:433:
+    log_error("  -st <n> stride (default %i)\n",d->stride) ;
                                                ^

ERROR: line over 90 characters
#8077: FILE: tests/tcg/aarch64/litmus/utils.c:438:
+    log_error("  -i <n>  increment for allocating logical processors, -i 0 
disables affinity mode") ;

ERROR: suspect code indent for conditional statements (4, 6)
#8078: FILE: tests/tcg/aarch64/litmus/utils.c:439:
+    if (d->aff_mode == aff_incr) {
+      log_error(" (default %i)\n",d->aff_incr) ;

ERROR: space required after that ',' (ctx:VxV)
#8079: FILE: tests/tcg/aarch64/litmus/utils.c:440:
+      log_error(" (default %i)\n",d->aff_incr) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#8084: FILE: tests/tcg/aarch64/litmus/utils.c:445:
+    cpus_dump(errlog,d->aff_cpus) ;
                     ^

ERROR: line over 90 characters
#8086: FILE: tests/tcg/aarch64/litmus/utils.c:447:
+    log_error("  +ra     randomise affinity%s\n",d->aff_mode == aff_random ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8086: FILE: tests/tcg/aarch64/litmus/utils.c:447:
+    log_error("  +ra     randomise affinity%s\n",d->aff_mode == aff_random ? " 
(default)" : "") ;
                                                 ^

ERROR: suspect code indent for conditional statements (4, 6)
#8087: FILE: tests/tcg/aarch64/litmus/utils.c:448:
+    if (d->aff_custom_enabled) {
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;

ERROR: line over 90 characters
#8088: FILE: tests/tcg/aarch64/litmus/utils.c:449:
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8088: FILE: tests/tcg/aarch64/litmus/utils.c:449:
+      log_error("  +ca     enable custom affinity%s\n",d->aff_mode == 
aff_custom ? " (default)" : "") ;
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8092: FILE: tests/tcg/aarch64/litmus/utils.c:453:
+    if (d->aff_scan_enabled) {
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;

ERROR: line over 90 characters
#8093: FILE: tests/tcg/aarch64/litmus/utils.c:454:
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8093: FILE: tests/tcg/aarch64/litmus/utils.c:454:
+      log_error("  +sa     enable scanning affinity%s\n",d->aff_mode == 
aff_scan ? " (default)" : "") ;
                                                         ^

WARNING: line over 80 characters
#8100: FILE: tests/tcg/aarch64/litmus/utils.c:461:
+    log_error("  +rm     randomise memory accesses%s\n",d->shuffle ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8100: FILE: tests/tcg/aarch64/litmus/utils.c:461:
+    log_error("  +rm     randomise memory accesses%s\n",d->shuffle ? " 
(default)" : "") ;
                                                        ^

ERROR: line over 90 characters
#8101: FILE: tests/tcg/aarch64/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxO)
#8101: FILE: tests/tcg/aarch64/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;
                                                               ^

ERROR: space required before that '!' (ctx:OxV)
#8101: FILE: tests/tcg/aarch64/litmus/utils.c:462:
+    log_error("  -rm     do not randomise memory accesses%s\n",!d->shuffle ? " 
(default)" : "") ;
                                                                ^

ERROR: line over 90 characters
#8104: FILE: tests/tcg/aarch64/litmus/utils.c:465:
+    log_error("  +sc     stop as soon as possible%s\n",d->speedcheck ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8104: FILE: tests/tcg/aarch64/litmus/utils.c:465:
+    log_error("  +sc     stop as soon as possible%s\n",d->speedcheck ? " 
(default)" : "") ;
                                                       ^

WARNING: line over 80 characters
#8105: FILE: tests/tcg/aarch64/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;

ERROR: space required after that ',' (ctx:VxO)
#8105: FILE: tests/tcg/aarch64/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;
                                                 ^

ERROR: space required before that '!' (ctx:OxV)
#8105: FILE: tests/tcg/aarch64/litmus/utils.c:466:
+    log_error("  -sc     run test completly%s\n",!d->speedcheck ? " (default)" 
: "") ;
                                                  ^

ERROR: space required after that ',' (ctx:VxV)
#8112: FILE: tests/tcg/aarch64/litmus/utils.c:473:
+    ints_dump(errlog,d->delta_tb) ;
                     ^

ERROR: line over 90 characters
#8118: FILE: tests/tcg/aarch64/litmus/utils.c:479:
+    log_error("  +vb     show iteration timings%s\n",d->verbose_barrier ? " 
(default)" : "") ;

ERROR: space required after that ',' (ctx:VxV)
#8118: FILE: tests/tcg/aarch64/litmus/utils.c:479:
+    log_error("  +vb     show iteration timings%s\n",d->verbose_barrier ? " 
(default)" : "") ;
                                                     ^

ERROR: line over 90 characters
#8119: FILE: tests/tcg/aarch64/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;

ERROR: space required after that ',' (ctx:VxO)
#8119: FILE: tests/tcg/aarch64/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
                                                            ^

ERROR: space required before that '!' (ctx:OxV)
#8119: FILE: tests/tcg/aarch64/litmus/utils.c:480:
+    log_error("  -vb     do not show iteration 
timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
                                                             ^

ERROR: space required after that ',' (ctx:VxV)
#8124: FILE: tests/tcg/aarch64/litmus/utils.c:485:
+    prefetch_dump(errlog,d->prefetch) ;
                         ^

ERROR: line over 90 characters
#8129: FILE: tests/tcg/aarch64/litmus/utils.c:490:
+    log_error("  -prs <n> prefetch probability is 1/n, -prs 0 disables 
feature, default %i\n",d->static_prefetch) ;

ERROR: space required after that ',' (ctx:VxV)
#8129: FILE: tests/tcg/aarch64/litmus/utils.c:490:
+    log_error("  -prs <n> prefetch probability is 1/n, -prs 0 disables 
feature, default %i\n",d->static_prefetch) ;
                                                                                
              ^

ERROR: line over 90 characters
#8132: FILE: tests/tcg/aarch64/litmus/utils.c:493:
+    log_error("  -l <n>  measure time by running assembly in a loop of size 
<n> (default %i)\n",d->max_loop) ;

ERROR: space required after that ',' (ctx:VxV)
#8132: FILE: tests/tcg/aarch64/litmus/utils.c:493:
+    log_error("  -l <n>  measure time by running assembly in a loop of size 
<n> (default %i)\n",d->max_loop) ;
                                                                                
                ^

ERROR: space required after that ',' (ctx:VxV)
#8138: FILE: tests/tcg/aarch64/litmus/utils.c:499:
+    log_error("  -k <n>  undocumented (default %i)\n",d->sync_n) ;
                                                      ^

ERROR: space prohibited between function name and open parenthesis '('
#8143: FILE: tests/tcg/aarch64/litmus/utils.c:504:
+static long my_add (long x, long y) {

ERROR: spaces required around that '+' (ctx:VxV)
#8144: FILE: tests/tcg/aarch64/litmus/utils.c:505:
+  long r = x+y ;
             ^

ERROR: trailing statements should be on next line
#8145: FILE: tests/tcg/aarch64/litmus/utils.c:506:
+  if (r < x || r < y) { errno = ERANGE ; fatal("overflow") ; }

ERROR: open brace '{' following function declarations go on the next line
#8149: FILE: tests/tcg/aarch64/litmus/utils.c:510:
+static long my_pow10(int p,long x) {

ERROR: space required after that ',' (ctx:VxV)
#8149: FILE: tests/tcg/aarch64/litmus/utils.c:510:
+static long my_pow10(int p,long x) {
                           ^

ERROR: space required after that ',' (ctx:VxV)
#8152: FILE: tests/tcg/aarch64/litmus/utils.c:513:
+    long y2 = my_add(r,r) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8153: FILE: tests/tcg/aarch64/litmus/utils.c:514:
+    long y4 = my_add(y2,y2) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#8154: FILE: tests/tcg/aarch64/litmus/utils.c:515:
+    long y8 = my_add(y4,y4) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#8155: FILE: tests/tcg/aarch64/litmus/utils.c:516:
+    r = my_add(y8,y2) ;
                  ^

ERROR: trailing statements should be on next line
#8157: FILE: tests/tcg/aarch64/litmus/utils.c:518:
+  if (r >= INT_MAX || r <= 0) {  errno = ERANGE ; fatal("overflow") ; }

ERROR: open brace '{' following function declarations go on the next line
#8161: FILE: tests/tcg/aarch64/litmus/utils.c:522:
+static int do_argint(char *p, char **q) {

ERROR: space required after that ',' (ctx:VxV)
#8162: FILE: tests/tcg/aarch64/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#8162: FILE: tests/tcg/aarch64/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;
                       ^

ERROR: consider using qemu_strtol in preference to strtol
#8162: FILE: tests/tcg/aarch64/litmus/utils.c:523:
+  long r =  strtol(p,q,10) ;

ERROR: trailing statements should be on next line
#8163: FILE: tests/tcg/aarch64/litmus/utils.c:524:
+  if (errno == ERANGE) { fatal("overflow") ; }

ERROR: space required after that ',' (ctx:VxV)
#8164: FILE: tests/tcg/aarch64/litmus/utils.c:525:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }
                                                 ^

ERROR: trailing statements should be on next line
#8164: FILE: tests/tcg/aarch64/litmus/utils.c:525:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }

ERROR: space required after that ',' (ctx:VxV)
#8165: FILE: tests/tcg/aarch64/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }
                                                      ^

ERROR: spaces required around that '+=' (ctx:WxV)
#8165: FILE: tests/tcg/aarch64/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }
                                                               ^

ERROR: trailing statements should be on next line
#8165: FILE: tests/tcg/aarch64/litmus/utils.c:526:
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }

ERROR: else should follow close brace '}'
#8165: FILE: tests/tcg/aarch64/litmus/utils.c:526:
+  if (**q == 'k' || **q == 'K') { r = my_pow10(3,r) ; *q += 1; }
+  else if (**q == 'm' || **q == 'M') { r = my_pow10(6,r) ; *q +=1 ; }

ERROR: open brace '{' following function declarations go on the next line
#8169: FILE: tests/tcg/aarch64/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#8169: FILE: tests/tcg/aarch64/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#8169: FILE: tests/tcg/aarch64/litmus/utils.c:530:
+static int argint(char *prog,char *p,cmd_t *d) {
                                     ^

ERROR: space required after that ',' (ctx:VxO)
#8171: FILE: tests/tcg/aarch64/litmus/utils.c:532:
+  long r = do_argint(p,&q) ;
                       ^

ERROR: space required before that '&' (ctx:OxV)
#8171: FILE: tests/tcg/aarch64/litmus/utils.c:532:
+  long r = do_argint(p,&q) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#8173: FILE: tests/tcg/aarch64/litmus/utils.c:534:
+    usage(prog,d) ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#8178: FILE: tests/tcg/aarch64/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#8178: FILE: tests/tcg/aarch64/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#8178: FILE: tests/tcg/aarch64/litmus/utils.c:539:
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
                                           ^

ERROR: space required after that ',' (ctx:VxO)
#8185: FILE: tests/tcg/aarch64/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                          ^

ERROR: space required before that '&' (ctx:OxV)
#8185: FILE: tests/tcg/aarch64/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#8185: FILE: tests/tcg/aarch64/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;
                             ^

ERROR: consider using qemu_strtol in preference to strtol
#8185: FILE: tests/tcg/aarch64/litmus/utils.c:546:
+    int x = (int)strtol(p,&q,10) ;

ERROR: space required after that ',' (ctx:VxV)
#8186: FILE: tests/tcg/aarch64/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
                                                                      ^

ERROR: trailing statements should be on next line
#8186: FILE: tests/tcg/aarch64/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8186: FILE: tests/tcg/aarch64/litmus/utils.c:547:
+    if (x < 0 || *p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
[...]

ERROR: trailing statements should be on next line
#8188: FILE: tests/tcg/aarch64/litmus/utils.c:549:
+    if (*q == '\0') break ;

ERROR: braces {} are necessary for all arms of this statement
#8188: FILE: tests/tcg/aarch64/litmus/utils.c:549:
+    if (*q == '\0') break ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#8189: FILE: tests/tcg/aarch64/litmus/utils.c:550:
+    p = q+1 ;
          ^

ERROR: space required after that ',' (ctx:VxO)
#8195: FILE: tests/tcg/aarch64/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                              ^

ERROR: space required before that '&' (ctx:OxV)
#8195: FILE: tests/tcg/aarch64/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#8195: FILE: tests/tcg/aarch64/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;
                                 ^

ERROR: consider using qemu_strtol in preference to strtol
#8195: FILE: tests/tcg/aarch64/litmus/utils.c:556:
+    r->cpu[k] = (int)strtol(p,&q,10) ;

ERROR: spaces required around that '+' (ctx:VxV)
#8196: FILE: tests/tcg/aarch64/litmus/utils.c:557:
+    p = q+1 ;
          ^

ERROR: open brace '{' following function declarations go on the next line
#8201: FILE: tests/tcg/aarch64/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#8201: FILE: tests/tcg/aarch64/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
                               ^

ERROR: space required after that ',' (ctx:VxV)
#8201: FILE: tests/tcg/aarch64/litmus/utils.c:562:
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
                                                 ^

ERROR: space required after that ',' (ctx:VxO)
#8204: FILE: tests/tcg/aarch64/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                            ^

ERROR: space required before that '&' (ctx:OxV)
#8204: FILE: tests/tcg/aarch64/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#8204: FILE: tests/tcg/aarch64/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;
                               ^

ERROR: consider using qemu_strtol in preference to strtol
#8204: FILE: tests/tcg/aarch64/litmus/utils.c:565:
+    int idx = (int)strtol(p,&q,10) ;

ERROR: space required after that ',' (ctx:VxV)
#8205: FILE: tests/tcg/aarch64/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;
                                                                        ^

ERROR: trailing statements should be on next line
#8205: FILE: tests/tcg/aarch64/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8205: FILE: tests/tcg/aarch64/litmus/utils.c:566:
+    if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':')  usage(prog,d) ;
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#8206: FILE: tests/tcg/aarch64/litmus/utils.c:567:
+    p = q+1 ;
          ^

ERROR: space required after that ',' (ctx:VxO)
#8207: FILE: tests/tcg/aarch64/litmus/utils.c:568:
+    int v = do_argint(p,&q) ;
                        ^

ERROR: space required before that '&' (ctx:OxV)
#8207: FILE: tests/tcg/aarch64/litmus/utils.c:568:
+    int v = do_argint(p,&q) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#8208: FILE: tests/tcg/aarch64/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
                                                             ^

ERROR: trailing statements should be on next line
#8208: FILE: tests/tcg/aarch64/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8208: FILE: tests/tcg/aarch64/litmus/utils.c:569:
+    if (*p == '\0' || (*q != '\0' && *q != ','))  usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#8210: FILE: tests/tcg/aarch64/litmus/utils.c:571:
+    if (*q == '\0') {
+      p = q ;

ERROR: spaces required around that '+' (ctx:VxV)
#8213: FILE: tests/tcg/aarch64/litmus/utils.c:574:
+      p = q+1 ;
            ^

ERROR: open brace '{' following function declarations go on the next line
#8218: FILE: tests/tcg/aarch64/litmus/utils.c:579:
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {

ERROR: space required after that ',' (ctx:VxV)
#8218: FILE: tests/tcg/aarch64/litmus/utils.c:579:
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#8222: FILE: tests/tcg/aarch64/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
                    ^

ERROR: trailing statements should be on next line
#8222: FILE: tests/tcg/aarch64/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;

ERROR: braces {} are necessary for all arms of this statement
#8222: FILE: tests/tcg/aarch64/litmus/utils.c:583:
+    if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#8228: FILE: tests/tcg/aarch64/litmus/utils.c:589:
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#8228: FILE: tests/tcg/aarch64/litmus/utils.c:589:
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#8241: FILE: tests/tcg/aarch64/litmus/utils.c:602:
+  set_prefetch(r,dir) ;
                 ^

ERROR: open brace '{' following function declarations go on the next line
#8244: FILE: tests/tcg/aarch64/litmus/utils.c:605:
+int parse_prefetch(char *p, prfdirs_t *r) {

ERROR: trailing statements should be on next line
#8245: FILE: tests/tcg/aarch64/litmus/utils.c:606:
+  if (!*p) return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#8245: FILE: tests/tcg/aarch64/litmus/utils.c:606:
+  if (!*p) return 1 ;
[...]

ERROR: space required after that ',' (ctx:VxO)
#8248: FILE: tests/tcg/aarch64/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                             ^

ERROR: space required before that '&' (ctx:OxV)
#8248: FILE: tests/tcg/aarch64/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#8248: FILE: tests/tcg/aarch64/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;
                                ^

ERROR: consider using qemu_strtol in preference to strtol
#8248: FILE: tests/tcg/aarch64/litmus/utils.c:609:
+    int proc = (int)strtol(p,&q,10) ;

ERROR: suspect code indent for conditional statements (4, 6)
#8249: FILE: tests/tcg/aarch64/litmus/utils.c:610:
+    if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
+      return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#8249: FILE: tests/tcg/aarch64/litmus/utils.c:610:
+    if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
[...]

ERROR: spaces required around that '+' (ctx:VxV)
#8251: FILE: tests/tcg/aarch64/litmus/utils.c:612:
+    p = q+1 ;
          ^

ERROR: suspect code indent for conditional statements (4, 6)
#8253: FILE: tests/tcg/aarch64/litmus/utils.c:614:
+    while (*p != '=') {
+      if (*p == '\0') return 0 ;

ERROR: trailing statements should be on next line
#8254: FILE: tests/tcg/aarch64/litmus/utils.c:615:
+      if (*p == '\0') return 0 ;

ERROR: braces {} are necessary for all arms of this statement
#8254: FILE: tests/tcg/aarch64/litmus/utils.c:615:
+      if (*p == '\0') return 0 ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8258: FILE: tests/tcg/aarch64/litmus/utils.c:619:
+    prfone_t *loc_slot = get_name_slot(&r->t[proc],p0) ;
                                                   ^

ERROR: suspect code indent for conditional statements (4, 6)
#8259: FILE: tests/tcg/aarch64/litmus/utils.c:620:
+    if (loc_slot == NULL) {
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;

ERROR: space required after that ',' (ctx:VxV)
#8260: FILE: tests/tcg/aarch64/litmus/utils.c:621:
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;
                                                        ^

ERROR: space required after that ',' (ctx:VxV)
#8260: FILE: tests/tcg/aarch64/litmus/utils.c:621:
+      log_error("Proc %i does not access variable %s\n",proc,p0) ;
                                                             ^

ERROR: trailing statements should be on next line
#8280: FILE: tests/tcg/aarch64/litmus/utils.c:641:
+    if (c == '\0') return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#8280: FILE: tests/tcg/aarch64/litmus/utils.c:641:
+    if (c == '\0') return 1 ;
[...]
+    else if (c == ',') p++ ;
[...]
+    else return 0 ;
[...]

ERROR: trailing statements should be on next line
#8281: FILE: tests/tcg/aarch64/litmus/utils.c:642:
+    else if (c == ',') p++ ;

ERROR: braces {} are necessary for all arms of this statement
#8281: FILE: tests/tcg/aarch64/litmus/utils.c:642:
+    else if (c == ',') p++ ;
[...]
+    else return 0 ;
[...]

ERROR: trailing statements should be on next line
#8282: FILE: tests/tcg/aarch64/litmus/utils.c:643:
+    else return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#8286: FILE: tests/tcg/aarch64/litmus/utils.c:647:
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {

ERROR: space required after that ',' (ctx:VxV)
#8286: FILE: tests/tcg/aarch64/litmus/utils.c:647:
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8287: FILE: tests/tcg/aarch64/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#8287: FILE: tests/tcg/aarch64/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
                                       ^

ERROR: trailing statements should be on next line
#8287: FILE: tests/tcg/aarch64/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8287: FILE: tests/tcg/aarch64/litmus/utils.c:648:
+  if (!parse_prefetch(p,r)) usage(prog,d) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#8290: FILE: tests/tcg/aarch64/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {

ERROR: space required after that ',' (ctx:VxV)
#8290: FILE: tests/tcg/aarch64/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8290: FILE: tests/tcg/aarch64/litmus/utils.c:651:
+static double argdouble(char *prog,char *p,cmd_t *d) {
                                           ^

ERROR: space required after that ',' (ctx:VxO)
#8292: FILE: tests/tcg/aarch64/litmus/utils.c:653:
+  double r = strtod(p,&q) ;
                      ^

ERROR: space required before that '&' (ctx:OxV)
#8292: FILE: tests/tcg/aarch64/litmus/utils.c:653:
+  double r = strtod(p,&q) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8294: FILE: tests/tcg/aarch64/litmus/utils.c:655:
+    usage(prog,d) ;
               ^

ERROR: open brace '{' following function declarations go on the next line
#8299: FILE: tests/tcg/aarch64/litmus/utils.c:660:
+void parse_cmd(int argc, char **argv, cmd_t *d, cmd_t *p) {

ERROR: trailing statements should be on next line
#8305: FILE: tests/tcg/aarch64/litmus/utils.c:666:
+    if (!*argv) break ;

ERROR: braces {} are necessary for all arms of this statement
#8305: FILE: tests/tcg/aarch64/litmus/utils.c:666:
+    if (!*argv) break ;
[...]

ERROR: trailing statements should be on next line
#8307: FILE: tests/tcg/aarch64/litmus/utils.c:668:
+    if (fst != '-' && fst != '+') break ;

ERROR: braces {} are necessary for all arms of this statement
#8307: FILE: tests/tcg/aarch64/litmus/utils.c:668:
+    if (fst != '-' && fst != '+') break ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8308: FILE: tests/tcg/aarch64/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
                     ^

ERROR: spaces required around that '=' (ctx:VxV)
#8308: FILE: tests/tcg/aarch64/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
                                            ^

ERROR: trailing statements should be on next line
#8308: FILE: tests/tcg/aarch64/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;

ERROR: braces {} are necessary for all arms of this statement
#8308: FILE: tests/tcg/aarch64/litmus/utils.c:669:
+    if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
[...]
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
[...]
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8309: FILE: tests/tcg/aarch64/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
                          ^

ERROR: trailing statements should be on next line
#8309: FILE: tests/tcg/aarch64/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;

ERROR: braces {} are necessary for all arms of this statement
#8309: FILE: tests/tcg/aarch64/litmus/utils.c:670:
+    else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
[...]
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#8310: FILE: tests/tcg/aarch64/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8310: FILE: tests/tcg/aarch64/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
                          ^

ERROR: braces {} are necessary for all arms of this statement
#8310: FILE: tests/tcg/aarch64/litmus/utils.c:671:
+    else if (strcmp(*argv,"-r") == 0) {
[...]
+    } else if (strcmp(*argv,"-fr") == 0) {
[...]
+    } else if (strcmp(*argv,"-s") == 0) {
[...]
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
[...]
+    } else if (strcmp(*argv,"-fs") == 0) {
[...]
+    } else if (strcmp(*argv,"-f") == 0) {
[...]
+    } else if (strcmp(*argv,"-n") == 0) {
[...]
+    } else if (strcmp(*argv,"-a") == 0) {
[...]
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
[...]
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
[...]
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
[...]
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
[...]
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
[...]
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
[...]
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
[...]
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
[...]
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
[...]
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
[...]
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
[...]
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
[...]
+    } else usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8312: FILE: tests/tcg/aarch64/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8312: FILE: tests/tcg/aarch64/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8312: FILE: tests/tcg/aarch64/litmus/utils.c:673:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8313: FILE: tests/tcg/aarch64/litmus/utils.c:674:
+      p->max_run = argint(prog,argv[0],d) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#8313: FILE: tests/tcg/aarch64/litmus/utils.c:674:
+      p->max_run = argint(prog,argv[0],d) ;
                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8314: FILE: tests/tcg/aarch64/litmus/utils.c:675:
+    } else if (strcmp(*argv,"-fr") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8314: FILE: tests/tcg/aarch64/litmus/utils.c:675:
+    } else if (strcmp(*argv,"-fr") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8316: FILE: tests/tcg/aarch64/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8316: FILE: tests/tcg/aarch64/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8316: FILE: tests/tcg/aarch64/litmus/utils.c:677:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8317: FILE: tests/tcg/aarch64/litmus/utils.c:678:
+      p->max_run *= argdouble(prog,argv[0],d) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8317: FILE: tests/tcg/aarch64/litmus/utils.c:678:
+      p->max_run *= argdouble(prog,argv[0],d) ;
                                           ^

ERROR: suspect code indent for conditional statements (4, 6)
#8318: FILE: tests/tcg/aarch64/litmus/utils.c:679:
+    } else if (strcmp(*argv,"-s") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8318: FILE: tests/tcg/aarch64/litmus/utils.c:679:
+    } else if (strcmp(*argv,"-s") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8320: FILE: tests/tcg/aarch64/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8320: FILE: tests/tcg/aarch64/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8320: FILE: tests/tcg/aarch64/litmus/utils.c:681:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8321: FILE: tests/tcg/aarch64/litmus/utils.c:682:
+      p->size_of_test = argint(prog,argv[0],d) ;
                                    ^

ERROR: space required after that ',' (ctx:VxV)
#8321: FILE: tests/tcg/aarch64/litmus/utils.c:682:
+      p->size_of_test = argint(prog,argv[0],d) ;
                                            ^

ERROR: suspect code indent for conditional statements (4, 6)
#8322: FILE: tests/tcg/aarch64/litmus/utils.c:683:
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8322: FILE: tests/tcg/aarch64/litmus/utils.c:683:
+    } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#8324: FILE: tests/tcg/aarch64/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8324: FILE: tests/tcg/aarch64/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8324: FILE: tests/tcg/aarch64/litmus/utils.c:685:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8325: FILE: tests/tcg/aarch64/litmus/utils.c:686:
+      p->stride = argint(prog,argv[0],d) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#8325: FILE: tests/tcg/aarch64/litmus/utils.c:686:
+      p->stride = argint(prog,argv[0],d) ;
                                      ^

ERROR: trailing statements should be on next line
#8326: FILE: tests/tcg/aarch64/litmus/utils.c:687:
+      if (p->stride <= 0) p->stride = 1 ;

ERROR: braces {} are necessary for all arms of this statement
#8326: FILE: tests/tcg/aarch64/litmus/utils.c:687:
+      if (p->stride <= 0) p->stride = 1 ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#8327: FILE: tests/tcg/aarch64/litmus/utils.c:688:
+    } else if (strcmp(*argv,"-fs") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8327: FILE: tests/tcg/aarch64/litmus/utils.c:688:
+    } else if (strcmp(*argv,"-fs") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8329: FILE: tests/tcg/aarch64/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8329: FILE: tests/tcg/aarch64/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8329: FILE: tests/tcg/aarch64/litmus/utils.c:690:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8330: FILE: tests/tcg/aarch64/litmus/utils.c:691:
+      p->size_of_test *= argdouble(prog,argv[0],d) ;
                                        ^

ERROR: space required after that ',' (ctx:VxV)
#8330: FILE: tests/tcg/aarch64/litmus/utils.c:691:
+      p->size_of_test *= argdouble(prog,argv[0],d) ;
                                                ^

ERROR: suspect code indent for conditional statements (4, 6)
#8331: FILE: tests/tcg/aarch64/litmus/utils.c:692:
+    } else if (strcmp(*argv,"-f") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8331: FILE: tests/tcg/aarch64/litmus/utils.c:692:
+    } else if (strcmp(*argv,"-f") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8333: FILE: tests/tcg/aarch64/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8333: FILE: tests/tcg/aarch64/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8333: FILE: tests/tcg/aarch64/litmus/utils.c:694:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8334: FILE: tests/tcg/aarch64/litmus/utils.c:695:
+      double f = argdouble(prog,argv[0],d) ;
                                ^

ERROR: space required after that ',' (ctx:VxV)
#8334: FILE: tests/tcg/aarch64/litmus/utils.c:695:
+      double f = argdouble(prog,argv[0],d) ;
                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#8337: FILE: tests/tcg/aarch64/litmus/utils.c:698:
+    } else if (strcmp(*argv,"-n") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8337: FILE: tests/tcg/aarch64/litmus/utils.c:698:
+    } else if (strcmp(*argv,"-n") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8339: FILE: tests/tcg/aarch64/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8339: FILE: tests/tcg/aarch64/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8339: FILE: tests/tcg/aarch64/litmus/utils.c:700:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8340: FILE: tests/tcg/aarch64/litmus/utils.c:701:
+      p->n_exe = argint(prog,argv[0],d) ;
                             ^

ERROR: space required after that ',' (ctx:VxV)
#8340: FILE: tests/tcg/aarch64/litmus/utils.c:701:
+      p->n_exe = argint(prog,argv[0],d) ;
                                     ^

ERROR: trailing statements should be on next line
#8341: FILE: tests/tcg/aarch64/litmus/utils.c:702:
+      if (p->n_exe < 1) p->n_exe = 1 ;

ERROR: braces {} are necessary for all arms of this statement
#8341: FILE: tests/tcg/aarch64/litmus/utils.c:702:
+      if (p->n_exe < 1) p->n_exe = 1 ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#8342: FILE: tests/tcg/aarch64/litmus/utils.c:703:
+    } else if (strcmp(*argv,"-a") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8342: FILE: tests/tcg/aarch64/litmus/utils.c:703:
+    } else if (strcmp(*argv,"-a") == 0) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8344: FILE: tests/tcg/aarch64/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8344: FILE: tests/tcg/aarch64/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8344: FILE: tests/tcg/aarch64/litmus/utils.c:705:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8345: FILE: tests/tcg/aarch64/litmus/utils.c:706:
+      int a = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8345: FILE: tests/tcg/aarch64/litmus/utils.c:706:
+      int a = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#8347: FILE: tests/tcg/aarch64/litmus/utils.c:708:
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8347: FILE: tests/tcg/aarch64/litmus/utils.c:708:
+    } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
                                             ^

ERROR: space required after that ',' (ctx:VxV)
#8349: FILE: tests/tcg/aarch64/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8349: FILE: tests/tcg/aarch64/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8349: FILE: tests/tcg/aarch64/litmus/utils.c:710:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8350: FILE: tests/tcg/aarch64/litmus/utils.c:711:
+      int a = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8350: FILE: tests/tcg/aarch64/litmus/utils.c:711:
+      int a = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#8352: FILE: tests/tcg/aarch64/litmus/utils.c:713:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8352: FILE: tests/tcg/aarch64/litmus/utils.c:713:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#8354: FILE: tests/tcg/aarch64/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8354: FILE: tests/tcg/aarch64/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8354: FILE: tests/tcg/aarch64/litmus/utils.c:715:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8355: FILE: tests/tcg/aarch64/litmus/utils.c:716:
+      int i = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8355: FILE: tests/tcg/aarch64/litmus/utils.c:716:
+      int i = argint(prog,argv[0],d) ;
                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#8358: FILE: tests/tcg/aarch64/litmus/utils.c:719:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8358: FILE: tests/tcg/aarch64/litmus/utils.c:719:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
                                                       ^

ERROR: space required after that ',' (ctx:VxV)
#8360: FILE: tests/tcg/aarch64/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8360: FILE: tests/tcg/aarch64/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8360: FILE: tests/tcg/aarch64/litmus/utils.c:721:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8361: FILE: tests/tcg/aarch64/litmus/utils.c:722:
+      cpus_t *cpus = argcpus(prog,argv[0],d) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#8361: FILE: tests/tcg/aarch64/litmus/utils.c:722:
+      cpus_t *cpus = argcpus(prog,argv[0],d) ;
                                          ^

ERROR: suspect code indent for conditional statements (4, 6)
#8363: FILE: tests/tcg/aarch64/litmus/utils.c:724:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#8363: FILE: tests/tcg/aarch64/litmus/utils.c:724:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8365: FILE: tests/tcg/aarch64/litmus/utils.c:726:
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
+      p->aff_mode = aff_custom ;

ERROR: space required after that ',' (ctx:VxV)
#8365: FILE: tests/tcg/aarch64/litmus/utils.c:726:
+    } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
                                                     ^

ERROR: suspect code indent for conditional statements (4, 6)
#8367: FILE: tests/tcg/aarch64/litmus/utils.c:728:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#8367: FILE: tests/tcg/aarch64/litmus/utils.c:728:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8369: FILE: tests/tcg/aarch64/litmus/utils.c:730:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_scan ;

ERROR: space required after that ',' (ctx:VxV)
#8369: FILE: tests/tcg/aarch64/litmus/utils.c:730:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
                                                   ^

ERROR: suspect code indent for conditional statements (4, 6)
#8371: FILE: tests/tcg/aarch64/litmus/utils.c:732:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#8371: FILE: tests/tcg/aarch64/litmus/utils.c:732:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8373: FILE: tests/tcg/aarch64/litmus/utils.c:734:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
+      p->aff_mode = aff_topo ;

ERROR: space required after that ',' (ctx:VxV)
#8373: FILE: tests/tcg/aarch64/litmus/utils.c:734:
+    } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
                                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8376: FILE: tests/tcg/aarch64/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8376: FILE: tests/tcg/aarch64/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8376: FILE: tests/tcg/aarch64/litmus/utils.c:737:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: suspect code indent for conditional statements (4, 6)
#8378: FILE: tests/tcg/aarch64/litmus/utils.c:739:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+      p->aff_mode = aff_random ;

ERROR: space required after that ',' (ctx:VxV)
#8378: FILE: tests/tcg/aarch64/litmus/utils.c:739:
+    } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8380: FILE: tests/tcg/aarch64/litmus/utils.c:741:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
+      p->shuffle = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#8380: FILE: tests/tcg/aarch64/litmus/utils.c:741:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
                                               ^

ERROR: suspect code indent for conditional statements (4, 6)
#8382: FILE: tests/tcg/aarch64/litmus/utils.c:743:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
+      p->shuffle = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#8382: FILE: tests/tcg/aarch64/litmus/utils.c:743:
+    } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
                                               ^

ERROR: suspect code indent for conditional statements (4, 6)
#8384: FILE: tests/tcg/aarch64/litmus/utils.c:745:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
+      p->speedcheck = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#8384: FILE: tests/tcg/aarch64/litmus/utils.c:745:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
                                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#8386: FILE: tests/tcg/aarch64/litmus/utils.c:747:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
+      p->speedcheck = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#8386: FILE: tests/tcg/aarch64/litmus/utils.c:747:
+    } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
                                                  ^

ERROR: suspect code indent for conditional statements (4, 6)
#8388: FILE: tests/tcg/aarch64/litmus/utils.c:749:
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
+      p->fix = 1 ;

ERROR: space required after that ',' (ctx:VxV)
#8388: FILE: tests/tcg/aarch64/litmus/utils.c:749:
+    } else if (!d->fix &&  strcmp(*argv,"+fix") == 0) {
                                        ^

ERROR: suspect code indent for conditional statements (4, 6)
#8390: FILE: tests/tcg/aarch64/litmus/utils.c:751:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
+      p->verbose_barrier++ ;

ERROR: space required after that ',' (ctx:VxV)
#8390: FILE: tests/tcg/aarch64/litmus/utils.c:751:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8392: FILE: tests/tcg/aarch64/litmus/utils.c:753:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
+      p->verbose_barrier = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#8392: FILE: tests/tcg/aarch64/litmus/utils.c:753:
+    } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
                                                       ^

ERROR: suspect code indent for conditional statements (4, 6)
#8394: FILE: tests/tcg/aarch64/litmus/utils.c:755:
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
+      p->prelude = 0 ;

ERROR: space required after that ',' (ctx:VxV)
#8394: FILE: tests/tcg/aarch64/litmus/utils.c:755:
+    } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
                                              ^

ERROR: suspect code indent for conditional statements (4, 6)
#8396: FILE: tests/tcg/aarch64/litmus/utils.c:757:
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8396: FILE: tests/tcg/aarch64/litmus/utils.c:757:
+    } else if (d->delta_tb &&  strcmp(*argv,"-tb") == 0) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#8398: FILE: tests/tcg/aarch64/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8398: FILE: tests/tcg/aarch64/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8398: FILE: tests/tcg/aarch64/litmus/utils.c:759:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8399: FILE: tests/tcg/aarch64/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                   ^

ERROR: space required after that ',' (ctx:VxV)
#8399: FILE: tests/tcg/aarch64/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#8399: FILE: tests/tcg/aarch64/litmus/utils.c:760:
+      argints(prog,d,argv[0],p->delta_tb) ;
                             ^

ERROR: suspect code indent for conditional statements (4, 6)
#8400: FILE: tests/tcg/aarch64/litmus/utils.c:761:
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8400: FILE: tests/tcg/aarch64/litmus/utils.c:761:
+    } else if (d->delta_tb &&  strcmp(*argv,"-ta") == 0) {
                                            ^

ERROR: space required after that ',' (ctx:VxV)
#8402: FILE: tests/tcg/aarch64/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8402: FILE: tests/tcg/aarch64/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8402: FILE: tests/tcg/aarch64/litmus/utils.c:763:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8403: FILE: tests/tcg/aarch64/litmus/utils.c:764:
+      int da = argint(prog,argv[0],d) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#8403: FILE: tests/tcg/aarch64/litmus/utils.c:764:
+      int da = argint(prog,argv[0],d) ;
                                   ^

ERROR: trailing statements should be on next line
#8404: FILE: tests/tcg/aarch64/litmus/utils.c:765:
+      for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;

ERROR: braces {} are necessary even for single statement blocks
#8404: FILE: tests/tcg/aarch64/litmus/utils.c:765:
+      for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;

ERROR: suspect code indent for conditional statements (4, 6)
#8405: FILE: tests/tcg/aarch64/litmus/utils.c:766:
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8405: FILE: tests/tcg/aarch64/litmus/utils.c:766:
+    } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#8407: FILE: tests/tcg/aarch64/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8407: FILE: tests/tcg/aarch64/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8407: FILE: tests/tcg/aarch64/litmus/utils.c:768:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8408: FILE: tests/tcg/aarch64/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8408: FILE: tests/tcg/aarch64/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#8408: FILE: tests/tcg/aarch64/litmus/utils.c:769:
+      argprefetch(prog,d,argv[0],p->prefetch) ;
                                 ^

ERROR: suspect code indent for conditional statements (4, 6)
#8409: FILE: tests/tcg/aarch64/litmus/utils.c:770:
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8409: FILE: tests/tcg/aarch64/litmus/utils.c:770:
+    } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#8411: FILE: tests/tcg/aarch64/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8411: FILE: tests/tcg/aarch64/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8411: FILE: tests/tcg/aarch64/litmus/utils.c:772:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8412: FILE: tests/tcg/aarch64/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8412: FILE: tests/tcg/aarch64/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8412: FILE: tests/tcg/aarch64/litmus/utils.c:773:
+      argoneprefetch(prog,d,argv[0],p->prefetch) ;
                                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#8413: FILE: tests/tcg/aarch64/litmus/utils.c:774:
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8413: FILE: tests/tcg/aarch64/litmus/utils.c:774:
+    } else  if (d->static_prefetch >= 0 &&  strcmp(*argv,"-prs") == 0) {
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#8415: FILE: tests/tcg/aarch64/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8415: FILE: tests/tcg/aarch64/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8415: FILE: tests/tcg/aarch64/litmus/utils.c:776:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8416: FILE: tests/tcg/aarch64/litmus/utils.c:777:
+      int prs = argint(prog,argv[0],d) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8416: FILE: tests/tcg/aarch64/litmus/utils.c:777:
+      int prs = argint(prog,argv[0],d) ;
                                    ^

ERROR: suspect code indent for conditional statements (4, 6)
#8418: FILE: tests/tcg/aarch64/litmus/utils.c:779:
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
+      --argc ; ++argv ;

ERROR: space required after that ',' (ctx:VxV)
#8418: FILE: tests/tcg/aarch64/litmus/utils.c:779:
+    } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
                                               ^

ERROR: space required after that ',' (ctx:VxV)
#8420: FILE: tests/tcg/aarch64/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;
                             ^

ERROR: trailing statements should be on next line
#8420: FILE: tests/tcg/aarch64/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;

ERROR: braces {} are necessary for all arms of this statement
#8420: FILE: tests/tcg/aarch64/litmus/utils.c:781:
+      if (!*argv) usage(prog,d) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8421: FILE: tests/tcg/aarch64/litmus/utils.c:782:
+      int i = argint(prog,argv[0],d) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#8421: FILE: tests/tcg/aarch64/litmus/utils.c:782:
+      int i = argint(prog,argv[0],d) ;
                                  ^

ERROR: space required after that ',' (ctx:VxV)
#8423: FILE: tests/tcg/aarch64/litmus/utils.c:784:
+    } else usage(prog,d) ;
                      ^

ERROR: trailing statements should be on next line
#8423: FILE: tests/tcg/aarch64/litmus/utils.c:784:
+    } else usage(prog,d) ;

ERROR: trailing statements should be on next line
#8427: FILE: tests/tcg/aarch64/litmus/utils.c:788:
+  if (argc == 0) return ;

ERROR: braces {} are necessary for all arms of this statement
#8427: FILE: tests/tcg/aarch64/litmus/utils.c:788:
+  if (argc == 0) return ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8428: FILE: tests/tcg/aarch64/litmus/utils.c:789:
+  usage(prog,d) ;
             ^

ERROR: open brace '{' following function declarations go on the next line
#8437: FILE: tests/tcg/aarch64/litmus/utils.c:798:
+pm_t *pm_create(void) {

ERROR: space required after that ',' (ctx:VxV)
#8439: FILE: tests/tcg/aarch64/litmus/utils.c:800:
+  int ret = pthread_mutex_init(p,NULL) ;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#8440: FILE: tests/tcg/aarch64/litmus/utils.c:801:
+  if (ret) { errexit("mutex_init",ret) ; }
                                  ^

ERROR: trailing statements should be on next line
#8440: FILE: tests/tcg/aarch64/litmus/utils.c:801:
+  if (ret) { errexit("mutex_init",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#8444: FILE: tests/tcg/aarch64/litmus/utils.c:805:
+void pm_free(pm_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8448: FILE: tests/tcg/aarch64/litmus/utils.c:809:
+void pm_lock(pm_t *m) {

ERROR: space required after that ',' (ctx:VxV)
#8450: FILE: tests/tcg/aarch64/litmus/utils.c:811:
+  if (ret) { errexit("mutex_lock",ret) ; }
                                  ^

ERROR: trailing statements should be on next line
#8450: FILE: tests/tcg/aarch64/litmus/utils.c:811:
+  if (ret) { errexit("mutex_lock",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#8453: FILE: tests/tcg/aarch64/litmus/utils.c:814:
+void pm_unlock(pm_t *m) {

ERROR: space required after that ',' (ctx:VxV)
#8455: FILE: tests/tcg/aarch64/litmus/utils.c:816:
+  if (ret) { errexit("mutex_unlock",ret) ; }
                                    ^

ERROR: trailing statements should be on next line
#8455: FILE: tests/tcg/aarch64/litmus/utils.c:816:
+  if (ret) { errexit("mutex_unlock",ret) ; }

ERROR: open brace '{' following function declarations go on the next line
#8460: FILE: tests/tcg/aarch64/litmus/utils.c:821:
+pc_t *pc_create(void) {

ERROR: space required after that ',' (ctx:VxV)
#8464: FILE: tests/tcg/aarch64/litmus/utils.c:825:
+  int e = pthread_cond_init(p->c_cond,NULL) ;
                                      ^

ERROR: space required after that ',' (ctx:VxV)
#8465: FILE: tests/tcg/aarch64/litmus/utils.c:826:
+  if (e) { errexit("cond_init",e); }
                               ^

ERROR: trailing statements should be on next line
#8465: FILE: tests/tcg/aarch64/litmus/utils.c:826:
+  if (e) { errexit("cond_init",e); }

ERROR: open brace '{' following function declarations go on the next line
#8469: FILE: tests/tcg/aarch64/litmus/utils.c:830:
+void pc_free(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8475: FILE: tests/tcg/aarch64/litmus/utils.c:836:
+static void pc_lock(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8479: FILE: tests/tcg/aarch64/litmus/utils.c:840:
+static void pc_unlock(pc_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8483: FILE: tests/tcg/aarch64/litmus/utils.c:844:
+void pc_wait(pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#8485: FILE: tests/tcg/aarch64/litmus/utils.c:846:
+  if (e) { errexit("cond_wait",e) ; }
                               ^

ERROR: trailing statements should be on next line
#8485: FILE: tests/tcg/aarch64/litmus/utils.c:846:
+  if (e) { errexit("cond_wait",e) ; }

ERROR: space prohibited between function name and open parenthesis '('
#8488: FILE: tests/tcg/aarch64/litmus/utils.c:849:
+void pc_broadcast (pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#8490: FILE: tests/tcg/aarch64/litmus/utils.c:851:
+  if (e) { errexit("cond_broadcast",e) ; }
                                    ^

ERROR: trailing statements should be on next line
#8490: FILE: tests/tcg/aarch64/litmus/utils.c:851:
+  if (e) { errexit("cond_broadcast",e) ; }

ERROR: open brace '{' following function declarations go on the next line
#8493: FILE: tests/tcg/aarch64/litmus/utils.c:854:
+static void pc_signal(pc_t *p) {

ERROR: space required after that ',' (ctx:VxV)
#8495: FILE: tests/tcg/aarch64/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;
                               ^

ERROR: trailing statements should be on next line
#8495: FILE: tests/tcg/aarch64/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;

ERROR: braces {} are necessary for all arms of this statement
#8495: FILE: tests/tcg/aarch64/litmus/utils.c:856:
+  if (e) errexit("cond_signal",e) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#8502: FILE: tests/tcg/aarch64/litmus/utils.c:863:
+pb_t *pb_create(int nprocs) {

ERROR: open brace '{' following function declarations go on the next line
#8510: FILE: tests/tcg/aarch64/litmus/utils.c:871:
+void pb_free(pb_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8516: FILE: tests/tcg/aarch64/litmus/utils.c:877:
+void pb_wait(pb_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#8525: FILE: tests/tcg/aarch64/litmus/utils.c:886:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#8535: FILE: tests/tcg/aarch64/litmus/utils.c:896:
+po_t *po_create(int nprocs) {

ERROR: open brace '{' following function declarations go on the next line
#8544: FILE: tests/tcg/aarch64/litmus/utils.c:905:
+void po_free(po_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8549: FILE: tests/tcg/aarch64/litmus/utils.c:910:
+void po_reinit(po_t *p) {

ERROR: suspect code indent for conditional statements (4, 6)
#8559: FILE: tests/tcg/aarch64/litmus/utils.c:920:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#8566: FILE: tests/tcg/aarch64/litmus/utils.c:927:
+int po_wait(po_t *p, int v) {

ERROR: suspect code indent for conditional statements (4, 6)
#8576: FILE: tests/tcg/aarch64/litmus/utils.c:937:
+    do {
+      pc_wait(p->cond) ;

ERROR: open brace '{' following function declarations go on the next line
#8588: FILE: tests/tcg/aarch64/litmus/utils.c:949:
+op_t *op_create(void) {

ERROR: open brace '{' following function declarations go on the next line
#8596: FILE: tests/tcg/aarch64/litmus/utils.c:957:
+void op_free(op_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8601: FILE: tests/tcg/aarch64/litmus/utils.c:962:
+void op_set(op_t *p, void *v) {

ERROR: trailing statements should be on next line
#8603: FILE: tests/tcg/aarch64/litmus/utils.c:964:
+  if (p->some) { fatal("op_set") ; }

ERROR: open brace '{' following function declarations go on the next line
#8610: FILE: tests/tcg/aarch64/litmus/utils.c:971:
+void *op_get(op_t *p) {

ERROR: open brace '{' following function declarations go on the next line
#8625: FILE: tests/tcg/aarch64/litmus/utils.c:986:
+void launch(pthread_t *th, f_t *f, void *a) {

ERROR: space required after that ',' (ctx:VxV)
#8626: FILE: tests/tcg/aarch64/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8626: FILE: tests/tcg/aarch64/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#8626: FILE: tests/tcg/aarch64/litmus/utils.c:987:
+  int e = pthread_create(th,NULL,f,a);
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8627: FILE: tests/tcg/aarch64/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);
                                 ^

ERROR: trailing statements should be on next line
#8627: FILE: tests/tcg/aarch64/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);

ERROR: braces {} are necessary for all arms of this statement
#8627: FILE: tests/tcg/aarch64/litmus/utils.c:988:
+  if (e) errexit("phread_create",e);
[...]

ERROR: open brace '{' following function declarations go on the next line
#8630: FILE: tests/tcg/aarch64/litmus/utils.c:991:
+void *join(pthread_t *th) {

ERROR: space required after that ',' (ctx:VxO)
#8632: FILE: tests/tcg/aarch64/litmus/utils.c:993:
+  int e = pthread_join(*th,&r) ;
                           ^

ERROR: space required before that '&' (ctx:OxV)
#8632: FILE: tests/tcg/aarch64/litmus/utils.c:993:
+  int e = pthread_join(*th,&r) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8633: FILE: tests/tcg/aarch64/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);
                                 ^

ERROR: trailing statements should be on next line
#8633: FILE: tests/tcg/aarch64/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);

ERROR: braces {} are necessary for all arms of this statement
#8633: FILE: tests/tcg/aarch64/litmus/utils.c:994:
+  if (e)  errexit("pthread_join",e);
[...]

ERROR: open brace '{' following function declarations go on the next line
#8645: FILE: tests/tcg/aarch64/litmus/utils.c:1006:
+static void *zyva_det(void *_b) {

ERROR: space required after that ',' (ctx:VxV)
#8652: FILE: tests/tcg/aarch64/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;
                                  ^

ERROR: trailing statements should be on next line
#8652: FILE: tests/tcg/aarch64/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;

ERROR: braces {} are necessary for all arms of this statement
#8652: FILE: tests/tcg/aarch64/litmus/utils.c:1013:
+  if (e) errexit("pthread_detach",e) ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8654: FILE: tests/tcg/aarch64/litmus/utils.c:1015:
+  op_set(op,r) ;
            ^

ERROR: open brace '{' following function declarations go on the next line
#8658: FILE: tests/tcg/aarch64/litmus/utils.c:1019:
+op_t *launch_detached(f_t *f,void *a) {

ERROR: space required after that ',' (ctx:VxV)
#8658: FILE: tests/tcg/aarch64/litmus/utils.c:1019:
+op_t *launch_detached(f_t *f,void *a) {
                             ^

ERROR: space required after that ',' (ctx:VxV)
#8663: FILE: tests/tcg/aarch64/litmus/utils.c:1024:
+  launch(&th,zyva_det,b) ;
             ^

ERROR: space required after that ',' (ctx:VxV)
#8663: FILE: tests/tcg/aarch64/litmus/utils.c:1024:
+  launch(&th,zyva_det,b) ;
                      ^

ERROR: open brace '{' following function declarations go on the next line
#8667: FILE: tests/tcg/aarch64/litmus/utils.c:1028:
+void *join_detached(op_t *op) {

ERROR: open brace '{' following function declarations go on the next line
#8675: FILE: tests/tcg/aarch64/litmus/utils.c:1036:
+void *start_thread(void *_a) {

ERROR: trailing statements should be on next line
#8680: FILE: tests/tcg/aarch64/litmus/utils.c:1041:
+    if (f == NULL) break ;

ERROR: braces {} are necessary for all arms of this statement
#8680: FILE: tests/tcg/aarch64/litmus/utils.c:1041:
+    if (f == NULL) break ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8682: FILE: tests/tcg/aarch64/litmus/utils.c:1043:
+    op_set(_b->op_ret,ret) ;
                      ^

ERROR: open brace '{' following function declarations go on the next line
#8691: FILE: tests/tcg/aarch64/litmus/utils.c:1052:
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {

ERROR: space required after that ',' (ctx:VxV)
#8691: FILE: tests/tcg/aarch64/litmus/utils.c:1052:
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {
                                   ^

ERROR: spaces required around that '+' (ctx:VxV)
#8694: FILE: tests/tcg/aarch64/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#8694: FILE: tests/tcg/aarch64/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#8694: FILE: tests/tcg/aarch64/litmus/utils.c:1055:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#8699: FILE: tests/tcg/aarch64/litmus/utils.c:1060:
+void perm_ints(unsigned *st,int *_t, int n) {

ERROR: space required after that ',' (ctx:VxV)
#8699: FILE: tests/tcg/aarch64/litmus/utils.c:1060:
+void perm_ints(unsigned *st,int *_t, int n) {
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8700: FILE: tests/tcg/aarch64/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                          ^

ERROR: spaces required around that '-' (ctx:VxV)
#8700: FILE: tests/tcg/aarch64/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                            ^

ERROR: space required after that ',' (ctx:VxV)
#8700: FILE: tests/tcg/aarch64/litmus/utils.c:1061:
+  perm_prefix_ints(st, _t,n-1,n) ;
                              ^

ERROR: open brace '{' following function declarations go on the next line
#8703: FILE: tests/tcg/aarch64/litmus/utils.c:1064:
+void perm_funs(unsigned *st,f_t *fun[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#8703: FILE: tests/tcg/aarch64/litmus/utils.c:1064:
+void perm_funs(unsigned *st,f_t *fun[], int n) {
                            ^

ERROR: spaces required around that '-' (ctx:VxV)
#8705: FILE: tests/tcg/aarch64/litmus/utils.c:1066:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#8706: FILE: tests/tcg/aarch64/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#8706: FILE: tests/tcg/aarch64/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#8706: FILE: tests/tcg/aarch64/litmus/utils.c:1067:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#8712: FILE: tests/tcg/aarch64/litmus/utils.c:1073:
+void perm_ops(unsigned *st,op_t *op[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#8712: FILE: tests/tcg/aarch64/litmus/utils.c:1073:
+void perm_ops(unsigned *st,op_t *op[], int n) {
                           ^

ERROR: spaces required around that '-' (ctx:VxV)
#8714: FILE: tests/tcg/aarch64/litmus/utils.c:1075:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#8715: FILE: tests/tcg/aarch64/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#8715: FILE: tests/tcg/aarch64/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#8715: FILE: tests/tcg/aarch64/litmus/utils.c:1076:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#8721: FILE: tests/tcg/aarch64/litmus/utils.c:1082:
+void perm_threads(unsigned *st,pthread_t thread[], int n) {

ERROR: space required after that ',' (ctx:VxV)
#8721: FILE: tests/tcg/aarch64/litmus/utils.c:1082:
+void perm_threads(unsigned *st,pthread_t thread[], int n) {
                               ^

ERROR: spaces required around that '-' (ctx:VxV)
#8723: FILE: tests/tcg/aarch64/litmus/utils.c:1084:
+  for (k = 0 ; k < n-1 ; k++) {
                     ^

ERROR: spaces required around that '+' (ctx:VxV)
#8724: FILE: tests/tcg/aarch64/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
              ^

ERROR: space required after that ',' (ctx:VxV)
#8724: FILE: tests/tcg/aarch64/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
                        ^

ERROR: spaces required around that '-' (ctx:VxV)
#8724: FILE: tests/tcg/aarch64/litmus/utils.c:1085:
+    int j = k+rand_k(st,n-k);
                          ^

ERROR: open brace '{' following function declarations go on the next line
#8730: FILE: tests/tcg/aarch64/litmus/utils.c:1091:
+static int int_cmp(const void *_p, const void *_q) {

ERROR: trailing statements should be on next line
#8733: FILE: tests/tcg/aarch64/litmus/utils.c:1094:
+  if (x < y) return -1 ;

ERROR: braces {} are necessary for all arms of this statement
#8733: FILE: tests/tcg/aarch64/litmus/utils.c:1094:
+  if (x < y) return -1 ;
[...]
+  else if (x > y) return 1 ;
[...]
+  else return 0 ;
[...]

ERROR: trailing statements should be on next line
#8734: FILE: tests/tcg/aarch64/litmus/utils.c:1095:
+  else if (x > y) return 1 ;

ERROR: braces {} are necessary for all arms of this statement
#8734: FILE: tests/tcg/aarch64/litmus/utils.c:1095:
+  else if (x > y) return 1 ;
[...]
+  else return 0 ;
[...]

ERROR: trailing statements should be on next line
#8735: FILE: tests/tcg/aarch64/litmus/utils.c:1096:
+  else return 0 ;

ERROR: open brace '{' following function declarations go on the next line
#8738: FILE: tests/tcg/aarch64/litmus/utils.c:1099:
+int check_shuffle(int **t, int *min, int sz) {

ERROR: spaces required around that '*' (ctx:VxV)
#8739: FILE: tests/tcg/aarch64/litmus/utils.c:1100:
+  int *idx = malloc_check(sizeof(*idx)*sz) ;
                                       ^

ERROR: spaces required around that '=' (ctx:VxV)
#8740: FILE: tests/tcg/aarch64/litmus/utils.c:1101:
+  for (int k=0 ; k < sz ; k++) {
             ^

ERROR: do not use C99 // comments
#8742: FILE: tests/tcg/aarch64/litmus/utils.c:1103:
+    //    fprintf(stderr," %i",idx[k]) ;

ERROR: do not use C99 // comments
#8744: FILE: tests/tcg/aarch64/litmus/utils.c:1105:
+  //  fprintf(stderr,"\n") ;

ERROR: space required after that ',' (ctx:VxV)
#8745: FILE: tests/tcg/aarch64/litmus/utils.c:1106:
+  qsort(&idx[0],sz, sizeof(idx[0]), int_cmp) ;
                ^

ERROR: spaces required around that '=' (ctx:VxV)
#8746: FILE: tests/tcg/aarch64/litmus/utils.c:1107:
+  for (int k=0 ; k < sz ; k++) {
             ^

ERROR: suspect code indent for conditional statements (4, 6)
#8747: FILE: tests/tcg/aarch64/litmus/utils.c:1108:
+    if (idx[k] != k) {
+      free(idx) ;

ERROR: open brace '{' following function declarations go on the next line
#8763: FILE: tests/tcg/aarch64/litmus/utils.c:1124:
+tsc_t timeofday(void) {

ERROR: space required after that ',' (ctx:VxV)
#8765: FILE: tests/tcg/aarch64/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8765: FILE: tests/tcg/aarch64/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
                                                    ^

ERROR: trailing statements should be on next line
#8765: FILE: tests/tcg/aarch64/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;

ERROR: braces {} are necessary for all arms of this statement
#8765: FILE: tests/tcg/aarch64/litmus/utils.c:1126:
+  if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
[...]

ERROR: open brace '{' following function declarations go on the next line
#8769: FILE: tests/tcg/aarch64/litmus/utils.c:1130:
+double tsc_ratio(tsc_t t1, tsc_t t2) {

ERROR: open brace '{' following function declarations go on the next line
#8774: FILE: tests/tcg/aarch64/litmus/utils.c:1135:
+double tsc_millions(tsc_t t) {

ERROR: open brace '{' following function declarations go on the next line
#8782: FILE: tests/tcg/aarch64/litmus/utils.c:1143:
+int find_string(char *t[], int sz, char *s) {

ERROR: space required after that ',' (ctx:VxV)
#8784: FILE: tests/tcg/aarch64/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;
                    ^

ERROR: trailing statements should be on next line
#8784: FILE: tests/tcg/aarch64/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;

ERROR: braces {} are necessary for all arms of this statement
#8784: FILE: tests/tcg/aarch64/litmus/utils.c:1145:
+    if (strcmp(t[k],s) == 0) return k ;
[...]

ERROR: space required after that ',' (ctx:VxV)
#8824: FILE: tests/tcg/aarch64/litmus/utils.h:31:
+int log_error(const char *fmt,...) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#8828: FILE: tests/tcg/aarch64/litmus/utils.h:35:
+void errexit(char *msg,int e) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8832: FILE: tests/tcg/aarch64/litmus/utils.h:39:
+int max(int n,int m) ;
              ^

ERROR: space prohibited between function name and open parenthesis '('
#8834: FILE: tests/tcg/aarch64/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;

ERROR: space required after that ',' (ctx:VxV)
#8834: FILE: tests/tcg/aarch64/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#8834: FILE: tests/tcg/aarch64/litmus/utils.h:41:
+void pp_ints (FILE *fp,int *p,int n) ;
                              ^

ERROR: space required after that ',' (ctx:VxV)
#8840: FILE: tests/tcg/aarch64/litmus/utils.h:47:
+void cat_file(char *path,char *msg,FILE *out) ;
                         ^

ERROR: space required after that ',' (ctx:VxV)
#8840: FILE: tests/tcg/aarch64/litmus/utils.h:47:
+void cat_file(char *path,char *msg,FILE *out) ;
                                   ^

ERROR: space required after that ',' (ctx:VxV)
#8856: FILE: tests/tcg/aarch64/litmus/utils.h:63:
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) ;
                                                         ^

ERROR: space required after that ',' (ctx:VxV)
#8864: FILE: tests/tcg/aarch64/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
          ^

ERROR: space required after that ',' (ctx:VxV)
#8864: FILE: tests/tcg/aarch64/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                     ^

ERROR: space required after that ',' (ctx:VxV)
#8864: FILE: tests/tcg/aarch64/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                 ^

ERROR: space required after that ',' (ctx:VxV)
#8864: FILE: tests/tcg/aarch64/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                           ^

ERROR: space required after that ',' (ctx:VxV)
#8864: FILE: tests/tcg/aarch64/litmus/utils.h:71:
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) 
;
                                                            ^

ERROR: open brace '{' following enum go on the same line
#8902: FILE: tests/tcg/aarch64/litmus/utils.h:109:
+typedef enum
+  { aff_none, aff_incr, aff_random, aff_custom,

ERROR: "foo * bar" should be "foo *bar"
#8926: FILE: tests/tcg/aarch64/litmus/utils.h:133:
+  ints_t * delta_tb ;

ERROR: space prohibited between function name and open parenthesis '('
#8966: FILE: tests/tcg/aarch64/litmus/utils.h:173:
+void pc_broadcast (pc_t *p) ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#8973: FILE: tests/tcg/aarch64/litmus/utils.h:180:
+  volatile unsigned int count ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#8974: FILE: tests/tcg/aarch64/litmus/utils.h:181:
+  volatile int turn ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#8991: FILE: tests/tcg/aarch64/litmus/utils.h:198:
+  volatile int val ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#8992: FILE: tests/tcg/aarch64/litmus/utils.h:199:
+  volatile int turn ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#9006: FILE: tests/tcg/aarch64/litmus/utils.h:213:
+  int volatile some ;

ERROR: Use of volatile is usually wrong: see 
Documentation/volatile-considered-harmful.txt
#9007: FILE: tests/tcg/aarch64/litmus/utils.h:214:
+  void * volatile val ;

ERROR: space required after that ',' (ctx:VxV)
#9025: FILE: tests/tcg/aarch64/litmus/utils.h:232:
+op_t *launch_detached(f_t *f,void *a) ;
                             ^

ERROR: space required after that ',' (ctx:VxO)
#9032: FILE: tests/tcg/aarch64/litmus/utils.h:239:
+  op_t *op_arg,*op_ret ;
               ^

ERROR: space required before that '*' (ctx:OxV)
#9032: FILE: tests/tcg/aarch64/litmus/utils.h:239:
+  op_t *op_arg,*op_ret ;
                ^

ERROR: space required after that ',' (ctx:VxV)
#9044: FILE: tests/tcg/aarch64/litmus/utils.h:251:
+void perm_prefix_ints(st_t *st,int t[], int used, int sz) ;
                               ^

ERROR: space required after that ',' (ctx:VxV)
#9045: FILE: tests/tcg/aarch64/litmus/utils.h:252:
+void perm_ints(st_t *st,int t[], int sz) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#9046: FILE: tests/tcg/aarch64/litmus/utils.h:253:
+void perm_funs(st_t *st,f_t *t[], int sz) ;
                        ^

ERROR: space required after that ',' (ctx:VxV)
#9047: FILE: tests/tcg/aarch64/litmus/utils.h:254:
+void perm_threads(st_t *st,pthread_t t[], int sz) ;
                           ^

ERROR: space required after that ',' (ctx:VxV)
#9048: FILE: tests/tcg/aarch64/litmus/utils.h:255:
+void perm_ops(st_t *st,op_t *t[], int sz) ;
                       ^

ERROR: space required after that ',' (ctx:VxV)
#9066: FILE: tests/tcg/aarch64/litmus/utils.h:273:
+int find_string(char *t[],int sz,char *s) ;
                          ^

ERROR: space required after that ',' (ctx:VxV)
#9066: FILE: tests/tcg/aarch64/litmus/utils.h:273:
+int find_string(char *t[],int sz,char *s) ;
                                 ^

total: 3821 errors, 78 warnings, 8908 lines checked

Your patch has style problems, please review.  If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.

Checking PATCH 3/3: travis: Enable litmus tests...
=== OUTPUT END ===

Test command exited with code: 1


---
Email generated automatically by Patchew [http://patchew.org/].
Please send your feedback to address@hidden

reply via email to

[Prev in Thread] Current Thread [Next in Thread]