* [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests
@ 2016-08-20 16:28 Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 1/3] tests/tcg: Add i386 litmus test Pranith Kumar
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Pranith Kumar @ 2016-08-20 16:28 UTC (permalink / raw)
To: qemu-devel; +Cc: alex.bennee
Hello,
The following patch series adds litmus tests to test consistency for
MTTCG enabled qemu. These patches apply on top of the clean up
tests/tcg folder made by my previous patch series.
The tests were generated using the litmus tool. The sources and
instructions on how to generate these sources can be found in this
repository: https://github.com/pranith/qemu-litmus
The litmus tests will fail if you do not have the barrier emitting
patch series applied and will pass otherwise. I tested these on both
an x86 and an Aarch64 machine. These tests are currently enabled on
the trusty configuration on travis.
These and all the patches necessary to successfully emit barrier
instructions can be found at the following location:
git://github.com/pranith/qemu fence_v4_litmus
Thanks!
Pranith Kumar (3):
tests/tcg: Add i386 litmus test
tests/tcg: Add aarch64 litmus tests
travis: Enable litmus tests
.travis.yml | 8 +
tests/tcg/aarch64/litmus/ARMARM00.c | 501 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM01.c | 504 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM02.c | 571 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM03.c | 498 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM04+BIS.c | 556 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM04+TER.c | 538 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM04.c | 556 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM05.c | 553 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM07+SAL.c | 497 +++++++++++++
tests/tcg/aarch64/litmus/Makefile | 53 ++
tests/tcg/aarch64/litmus/README.txt | 22 +
tests/tcg/aarch64/litmus/affinity.c | 159 ++++
tests/tcg/aarch64/litmus/affinity.h | 34 +
tests/tcg/aarch64/litmus/comp.sh | 30 +
tests/tcg/aarch64/litmus/litmus_rand.c | 64 ++
tests/tcg/aarch64/litmus/litmus_rand.h | 29 +
tests/tcg/aarch64/litmus/outs.c | 148 ++++
tests/tcg/aarch64/litmus/outs.h | 49 ++
tests/tcg/aarch64/litmus/run.sh | 378 ++++++++++
tests/tcg/aarch64/litmus/show.awk | 2 +
tests/tcg/aarch64/litmus/utils.c | 1148 +++++++++++++++++++++++++++++
tests/tcg/aarch64/litmus/utils.h | 275 +++++++
tests/tcg/i386/litmus/Makefile | 42 ++
tests/tcg/i386/litmus/README.txt | 22 +
tests/tcg/i386/litmus/SAL.c | 491 ++++++++++++
tests/tcg/i386/litmus/affinity.c | 159 ++++
tests/tcg/i386/litmus/affinity.h | 34 +
tests/tcg/i386/litmus/comp.sh | 10 +
tests/tcg/i386/litmus/litmus_rand.c | 64 ++
tests/tcg/i386/litmus/litmus_rand.h | 29 +
tests/tcg/i386/litmus/outs.c | 148 ++++
tests/tcg/i386/litmus/outs.h | 49 ++
tests/tcg/i386/litmus/run.sh | 55 ++
tests/tcg/i386/litmus/show.awk | 2 +
tests/tcg/i386/litmus/utils.c | 1148 +++++++++++++++++++++++++++++
tests/tcg/i386/litmus/utils.h | 275 +++++++
40 files changed, 11444 insertions(+)
create mode 100644 tests/tcg/aarch64/litmus/ARMARM00.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM01.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM02.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM03.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04+BIS.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04+TER.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM05.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM07+SAL.c
create mode 100644 tests/tcg/aarch64/litmus/Makefile
create mode 100644 tests/tcg/aarch64/litmus/README.txt
create mode 100644 tests/tcg/aarch64/litmus/affinity.c
create mode 100644 tests/tcg/aarch64/litmus/affinity.h
create mode 100644 tests/tcg/aarch64/litmus/comp.sh
create mode 100644 tests/tcg/aarch64/litmus/litmus_rand.c
create mode 100644 tests/tcg/aarch64/litmus/litmus_rand.h
create mode 100644 tests/tcg/aarch64/litmus/outs.c
create mode 100644 tests/tcg/aarch64/litmus/outs.h
create mode 100755 tests/tcg/aarch64/litmus/run.sh
create mode 100644 tests/tcg/aarch64/litmus/show.awk
create mode 100644 tests/tcg/aarch64/litmus/utils.c
create mode 100644 tests/tcg/aarch64/litmus/utils.h
create mode 100644 tests/tcg/i386/litmus/Makefile
create mode 100644 tests/tcg/i386/litmus/README.txt
create mode 100644 tests/tcg/i386/litmus/SAL.c
create mode 100644 tests/tcg/i386/litmus/affinity.c
create mode 100644 tests/tcg/i386/litmus/affinity.h
create mode 100644 tests/tcg/i386/litmus/comp.sh
create mode 100644 tests/tcg/i386/litmus/litmus_rand.c
create mode 100644 tests/tcg/i386/litmus/litmus_rand.h
create mode 100644 tests/tcg/i386/litmus/outs.c
create mode 100644 tests/tcg/i386/litmus/outs.h
create mode 100755 tests/tcg/i386/litmus/run.sh
create mode 100644 tests/tcg/i386/litmus/show.awk
create mode 100644 tests/tcg/i386/litmus/utils.c
create mode 100644 tests/tcg/i386/litmus/utils.h
--
2.9.3
^ permalink raw reply [flat|nested] 5+ messages in thread
* [Qemu-devel] [PATCH v2 1/3] tests/tcg: Add i386 litmus test
2016-08-20 16:28 [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests Pranith Kumar
@ 2016-08-20 16:28 ` Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 2/3] tests/tcg: Add aarch64 litmus tests Pranith Kumar
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Pranith Kumar @ 2016-08-20 16:28 UTC (permalink / raw)
To: qemu-devel; +Cc: alex.bennee
This adds the x86 store-after-load re-ordering litmus test.
Signed-off-by: Pranith Kumar <bobby.prani@gmail.com>
---
tests/tcg/i386/litmus/Makefile | 42 ++
tests/tcg/i386/litmus/README.txt | 22 +
tests/tcg/i386/litmus/SAL.c | 491 +++++++++++++++
tests/tcg/i386/litmus/affinity.c | 159 +++++
tests/tcg/i386/litmus/affinity.h | 34 ++
tests/tcg/i386/litmus/comp.sh | 10 +
tests/tcg/i386/litmus/litmus_rand.c | 64 ++
tests/tcg/i386/litmus/litmus_rand.h | 29 +
tests/tcg/i386/litmus/outs.c | 148 +++++
tests/tcg/i386/litmus/outs.h | 49 ++
tests/tcg/i386/litmus/run.sh | 55 ++
tests/tcg/i386/litmus/show.awk | 2 +
tests/tcg/i386/litmus/utils.c | 1148 +++++++++++++++++++++++++++++++++++
tests/tcg/i386/litmus/utils.h | 275 +++++++++
14 files changed, 2528 insertions(+)
create mode 100644 tests/tcg/i386/litmus/Makefile
create mode 100644 tests/tcg/i386/litmus/README.txt
create mode 100644 tests/tcg/i386/litmus/SAL.c
create mode 100644 tests/tcg/i386/litmus/affinity.c
create mode 100644 tests/tcg/i386/litmus/affinity.h
create mode 100644 tests/tcg/i386/litmus/comp.sh
create mode 100644 tests/tcg/i386/litmus/litmus_rand.c
create mode 100644 tests/tcg/i386/litmus/litmus_rand.h
create mode 100644 tests/tcg/i386/litmus/outs.c
create mode 100644 tests/tcg/i386/litmus/outs.h
create mode 100755 tests/tcg/i386/litmus/run.sh
create mode 100644 tests/tcg/i386/litmus/show.awk
create mode 100644 tests/tcg/i386/litmus/utils.c
create mode 100644 tests/tcg/i386/litmus/utils.h
diff --git a/tests/tcg/i386/litmus/Makefile b/tests/tcg/i386/litmus/Makefile
new file mode 100644
index 0000000..6b8fa37
--- /dev/null
+++ b/tests/tcg/i386/litmus/Makefile
@@ -0,0 +1,42 @@
+GCC=gcc
+GCCOPTS=-D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -fomit-frame-pointer -O2 -pthread
+LINKOPTS=
+SRC=\
+ SAL.c\
+
+EXE=$(SRC:.c=.exe)
+T=$(SRC:.c=.t)
+
+all: $(EXE) $(T)
+
+clean:
+ /bin/rm -f *.o *.s *.t *.exe *~
+
+cleansource:
+ /bin/rm -f *.o *.c *.h *.s *~
+
+affinity.o: affinity.c
+ $(GCC) $(GCCOPTS) -O2 -c affinity.c
+
+outs.o: outs.c
+ $(GCC) $(GCCOPTS) -O2 -c outs.c
+
+utils.o: utils.c
+ $(GCC) $(GCCOPTS) -O2 -c utils.c
+
+litmus_rand.o: litmus_rand.c
+ $(GCC) $(GCCOPTS) -O2 -c litmus_rand.c
+
+UTILS=affinity.o outs.o utils.o litmus_rand.o
+
+%.exe:%.s $(UTILS)
+ $(GCC) $(GCCOPTS) $(LINKOPTS) -o $@ $(UTILS) $<
+
+%.s:%.c
+ $(GCC) $(GCCOPTS) -S $<
+
+%.t:%.s
+ awk -f show.awk $< > $@
+
+tests: all
+ ./run.sh
diff --git a/tests/tcg/i386/litmus/README.txt b/tests/tcg/i386/litmus/README.txt
new file mode 100644
index 0000000..98ce238
--- /dev/null
+++ b/tests/tcg/i386/litmus/README.txt
@@ -0,0 +1,22 @@
+Tests produced by litmus for architecture X86 on linux
+
+COMPILING
+ with command 'make [-j N]' or 'sh comp.sh'
+
+RUNNING ALL TESTS
+ with command 'sh run.sh'. Test result on standard output.
+
+RUNNING ONE TEST
+ Tests are .exe files, for instance SAL.exe, run it by './SAL.exe'
+
+RUNNING OPTIONS
+ Main options to the run.sh script and to .exe files:
+ -v be verbose (can be repeated).
+ -a <n> number of (logical) processors available, default 0.
+ The default value of 0 means that .exe files attempt
+ to infer the actual number of logical threads.
+ -s <n> one run operates on arrays of size <n>, default 100000.
+ -r <n> number of runs, default 10.
+
+ For more options see for instance './SAL.exe -help' and litmus documentation
+ <http://diy.inria.fr/doc/litmus.html>
diff --git a/tests/tcg/i386/litmus/SAL.c b/tests/tcg/i386/litmus/SAL.c
new file mode 100644
index 0000000..1b66508
--- /dev/null
+++ b/tests/tcg/i386/litmus/SAL.c
@@ -0,0 +1,491 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 2
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("mfence" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_0_eax;
+ int *out_1_eax;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_0_eax,int _out_1_eax) {
+ switch (_out_0_eax) {
+ case 0:
+ switch (_out_1_eax) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 2
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_0_eax_f = 0 ;
+static const int out_1_eax_f = 1 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_0_eax = malloc_check(size_of_test*sizeof(*(_a->out_0_eax)));
+ _a->out_1_eax = malloc_check(size_of_test*sizeof(*(_a->out_1_eax)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_0_eax);
+ free((void *)_a->out_1_eax);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_0_eax[_i] = -239487;
+ _a->out_1_eax[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_0_eax = _a->out_0_eax;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"movl $1,%[x]\n"
+"#_litmus_P0_1\n\t"
+"mfence\n"
+"#_litmus_P0_2\n\t"
+"movl %[y],%[eax]\n"
+"#END _litmus_P0\n\t"
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_0_eax[_i])
+:
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_eax = _a->out_1_eax;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"movl $1,%[y]\n"
+"#_litmus_P1_1\n\t"
+"mfence\n"
+"#_litmus_P1_2\n\t"
+"movl %[x],%[eax]\n"
+"#END _litmus_P1\n\t"
+:[x] "=m" (_a->x[_i]),[y] "=m" (_a->y[_i]),[eax] "=&a" (out_1_eax[_i])
+:
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_0_eax_i = ctx.out_0_eax[_i];
+ int _out_1_eax_i = ctx.out_1_eax[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_0_eax_i,_out_1_eax_i));
+ o[out_0_eax_f] = _out_0_eax_i;
+ o[out_1_eax_f] = _out_1_eax_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test SAL Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (0:EAX=0 /\\ 1:EAX=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=d8f89591b2adad11d42d3eeb22d212c6\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("SAL, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("SAL, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/i386/litmus/affinity.c b/tests/tcg/i386/litmus/affinity.c
new file mode 100644
index 0000000..9535bf2
--- /dev/null
+++ b/tests/tcg/i386/litmus/affinity.c
@@ -0,0 +1,159 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdio.h>
+#include <sched.h>
+#include <unistd.h>
+#include "utils.h"
+#include "affinity.h"
+
+#ifdef CPUS_DEFINED
+cpus_t *read_affinity(void) {
+ cpu_set_t mask;
+ int sz = 0 ;
+ int res = pthread_getaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+
+ if (res != 0) {
+ errexit("pthread_getaffinity_np",res);
+ }
+ for (int p=0 ; p < CPU_SETSIZE ; p++) {
+ if (CPU_ISSET(p,&mask)) sz++ ;
+ }
+
+ cpus_t *r = cpus_create(sz) ;
+ for (int p=0, *q=r->cpu ; p < CPU_SETSIZE ; p++) {
+ if (CPU_ISSET(p,&mask)) *q++ = p ;
+ }
+ return r ;
+}
+
+#endif
+/* Attempt to force processors wake up, on devices where unused procs
+ go to sleep... */
+
+
+#ifdef FORCE_AFFINITY
+const static tsc_t sec = (tsc_t)1000000 ;
+
+static void* loop(void *p) {
+ tsc_t *q = p ;
+ tsc_t max = *q ;
+ while (timeofday() < max) ;
+ return NULL ;
+}
+
+
+static void warm_up(int sz, tsc_t d) {
+ pthread_t th[sz];
+ d += timeofday() ;
+ for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;
+ for (int k = 0 ; k < sz ; k++) join(&th[k]) ;
+}
+
+#ifdef CPUS_DEFINED
+cpus_t *read_force_affinity(int n_avail, int verbose) {
+ int sz = n_avail <= 1 ? 1 : n_avail ;
+ tsc_t max = sec / 100 ;
+
+ for ( ; ; ) {
+ warm_up(sz+1,max) ;
+ cpus_t *r = read_affinity() ;
+ if (n_avail <= r->sz) return r ;
+ if (verbose) {
+ fprintf(stderr,"Read affinity: '") ;
+ cpus_dump(stderr,r) ;
+ fprintf(stderr,"'\n") ;
+ }
+ cpus_free(r) ;
+ }
+}
+#endif
+#endif
+
+#ifdef CPUS_DEFINED
+
+/* Enforcing processor affinity.
+ Notice that logical processor numbers may be negative.
+ In that case, affinity setting is ignored */
+
+
+void write_affinity(cpus_t *p) {
+ cpu_set_t mask;
+ int exists_pos = 0 ;
+
+ CPU_ZERO(&mask) ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ if (p->cpu[k] >= 0) {
+ CPU_SET(p->cpu[k],&mask) ;
+ exists_pos = 1 ;
+ }
+ }
+ if (exists_pos) {
+ int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
+ if (r != 0) {
+ errexit("pthread_setaffinity_np",r) ;
+ }
+ }
+}
+#endif
+
+void write_one_affinity(int a) {
+ if (a >= 0) {
+ cpu_set_t mask;
+ CPU_ZERO(&mask) ;
+ CPU_SET(a,&mask) ;
+ int r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+ if (r != 0) {
+ errexit("pthread_setaffinity_np",r) ;
+ }
+ }
+}
+
+#ifdef FORCE_AFFINITY
+/* Get the number of present cpus, fragile */
+
+static const char *present = "/sys/devices/system/cpu/present" ;
+
+static int get_present(void) {
+ FILE *fp = fopen(present,"r") ;
+ if (fp == NULL) return -1 ;
+ int r1,r2 ;
+ int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
+ fclose(fp) ;
+ if (n != 2) return -1 ;
+ return r2-r1+1 ;
+}
+
+void force_one_affinity(int a, int sz,int verbose, char *name) {
+ if (a >= 0) {
+ cpu_set_t mask;
+ int r ;
+ CPU_ZERO(&mask) ;
+ CPU_SET(a,&mask) ;
+ do {
+ r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+ if (r != 0) {
+ if (verbose)
+ fprintf(stderr,"%s: force %i failed\n",name,a) ;
+ int nwarm = get_present() ;
+ if (verbose > 1)
+ fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
+ if (nwarm < 0) nwarm = sz+1 ;
+ warm_up(nwarm,sec/100) ;
+ }
+ } while (r != 0) ;
+ }
+}
+#endif
diff --git a/tests/tcg/i386/litmus/affinity.h b/tests/tcg/i386/litmus/affinity.h
new file mode 100644
index 0000000..9fb6a25
--- /dev/null
+++ b/tests/tcg/i386/litmus/affinity.h
@@ -0,0 +1,34 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _AFFINITY_H
+#define _AFFINITY_H 1
+
+#include "utils.h"
+
+#ifdef CPUS_DEFINED
+cpus_t *read_affinity(void) ;
+#ifdef FORCE_AFFINITY
+cpus_t *read_force_affinity(int n_avail, int verbose) ;
+#endif
+void write_affinity(cpus_t *p) ;
+#endif
+
+void write_one_affinity(int cpu) ;
+#ifdef FORCE_AFFINITY
+void force_one_affinity(int cpu, int sz, int verbose, char *name) ;
+#endif
+
+#endif
diff --git a/tests/tcg/i386/litmus/comp.sh b/tests/tcg/i386/litmus/comp.sh
new file mode 100644
index 0000000..251a710
--- /dev/null
+++ b/tests/tcg/i386/litmus/comp.sh
@@ -0,0 +1,10 @@
+GCC=gcc
+GCCOPTS="-D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -fomit-frame-pointer -O2 -pthread"
+LINKOPTS=""
+/bin/rm -f *.exe *.s
+$GCC $GCCOPTS -O2 -c affinity.c
+$GCC $GCCOPTS -O2 -c outs.c
+$GCC $GCCOPTS -O2 -c utils.c
+$GCC $GCCOPTS -O2 -c litmus_rand.c
+$GCC $GCCOPTS $LINKOPTS -o SAL.exe affinity.o outs.o utils.o litmus_rand.o SAL.c
+$GCC $GCCOPTS -S SAL.c && awk -f show.awk SAL.s > SAL.t && /bin/rm SAL.s
diff --git a/tests/tcg/i386/litmus/litmus_rand.c b/tests/tcg/i386/litmus/litmus_rand.c
new file mode 100644
index 0000000..de33032
--- /dev/null
+++ b/tests/tcg/i386/litmus/litmus_rand.c
@@ -0,0 +1,64 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdint.h>
+#include "litmus_rand.h"
+
+/*
+ Simple generator
+ http://en.wikipedia.org/wiki/Linear_congruential_generator
+*/
+
+
+/*
+
+ From ocaml sources: (globroot.c)
+ Linear congruence with modulus = 2^32, multiplier = 69069
+ (Knuth vol 2 p. 106, line 15 of table 1), additive = 25173.
+
+
+ Knuth (vol 2 p. 13) shows that the least significant bits are
+ "less random" than the most significant bits with a modulus of 2^m.
+ We just swap half words, enough? */
+
+static const uint32_t a = 69069;
+static const uint32_t c = 25173 ;
+
+inline static uint32_t unlocked_rand(st_t *st) {
+ uint32_t r = a * *st + c ;
+ *st = r ;
+ /* Swap high & low bits */
+ uint32_t low = r & 0xffff ;
+ uint32_t high = r >> 16 ;
+ r = high | (low << 16) ;
+ return r ;
+}
+
+int rand_bit(st_t *st) {
+ uint32_t r = unlocked_rand(st) ;
+ r &= 1 ;
+ return r ;
+}
+
+static const uint32_t r_max = UINT32_MAX ;
+
+uint32_t rand_k (uint32_t *st,uint32_t k) {
+ uint32_t r, v ;
+ do {
+ r = unlocked_rand(st) ;
+ v = r % k ;
+ } while (r-v > r_max-k+1) ;
+ return v ;
+}
diff --git a/tests/tcg/i386/litmus/litmus_rand.h b/tests/tcg/i386/litmus/litmus_rand.h
new file mode 100644
index 0000000..c358ccb
--- /dev/null
+++ b/tests/tcg/i386/litmus/litmus_rand.h
@@ -0,0 +1,29 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _LITMUS_RAND_H
+#define _LITMUS_RAND_H 1
+
+#include <stdint.h>
+
+/* type of state for pseudorandom generators */
+typedef uint32_t st_t ;
+
+/* Unlocked random bit */
+
+int rand_bit(st_t *st) ;
+uint32_t rand_k(st_t *st,uint32_t n) ;
+
+#endif
diff --git a/tests/tcg/i386/litmus/outs.c b/tests/tcg/i386/litmus/outs.c
new file mode 100644
index 0000000..178f1d2
--- /dev/null
+++ b/tests/tcg/i386/litmus/outs.c
@@ -0,0 +1,148 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include "outs.h"
+
+/**********************/
+/* Lexicographic tree */
+/**********************/
+
+#if 0
+static void debug(int *t, int i, int j) {
+ for (int k=i ; k <= j ; k++)
+ fprintf(stderr,"%i",t[k]) ;
+ fprintf(stderr,"\n") ;
+}
+#endif
+
+
+void *malloc_check(size_t sz) ;
+
+static outs_t *alloc_outs(intmax_t k) {
+ outs_t *r = malloc_check(sizeof(*r)) ;
+ r->k = k ;
+ r->c = 0 ;
+ r->show = 0 ;
+ r->next = r->down = NULL ;
+ return r ;
+}
+
+void free_outs(outs_t *p) {
+ if (p == NULL) return ;
+ free_outs(p->next) ;
+ free_outs(p->down) ;
+ free(p) ;
+}
+
+/* Worth writing as a loop, since called many times */
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, int show) {
+ outs_t *r = p ;
+ if (p == NULL || k[i] < p->k) {
+ r = alloc_outs(k[i]) ;
+ r->next = p ;
+ p = r ;
+ }
+ for ( ; ; ) {
+ outs_t **q ;
+ if (k[i] > p->k) {
+ q = &(p->next) ;
+ p = p->next ;
+ } else if (i <= 0) {
+ p->c += c ;
+ p->show = show || p->show ;
+ return r ;
+ } else {
+ i-- ;
+ q = &(p->down) ;
+ p = p->down ;
+ }
+ if (p == NULL || k[i] < p->k) {
+ outs_t *a = alloc_outs(k[i]) ;
+ a->next = p ;
+ p = a ;
+ *q = a ;
+ }
+ }
+}
+
+outs_t *add_outcome_outs(outs_t *p, intmax_t *k, int sz, count_t c, int show) {
+ return loop_add_outcome_outs(p,k,sz-1,c,show) ;
+}
+
+count_t sum_outs(outs_t *p) {
+ count_t r = 0 ;
+ for ( ; p ; p = p->next) {
+ r += p->c ;
+ r += sum_outs(p->down) ;
+ }
+ return r ;
+}
+
+int finals_outs(outs_t *p) {
+ int r = 0 ;
+ for ( ; p ; p = p->next) {
+ if (p->c > 0) r++ ;
+ r += finals_outs(p->down) ;
+ }
+ return r ;
+}
+
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int sz) {
+ for ( ; p ; p = p->next) {
+ buff[sz-1] = p->k ;
+ if (p->c > 0) {
+ dout(chan,buff,p->c,p->show) ;
+ } else if (p->down) {
+ dump_outs(chan,dout,p->down,buff,sz-1) ;
+ }
+ }
+}
+
+/* merge p and q into p */
+static outs_t *do_merge_outs(outs_t *p, outs_t *q) {
+ if (q == NULL) { // Nothing to add
+ return p ;
+ }
+ if (p == NULL || q->k < p->k) { // Need a cell
+ outs_t *r = alloc_outs(q->k) ;
+ r->next = p ;
+ p = r ;
+ }
+ if (p->k == q->k) {
+ p->c += q->c ;
+ p->show = p->show || q->show ;
+ p->down = do_merge_outs(p->down,q->down) ;
+ p->next = do_merge_outs(p->next,q->next) ;
+ } else {
+ p->next = do_merge_outs(p->next,q) ;
+ }
+ return p ;
+}
+
+outs_t *merge_outs(outs_t *p, outs_t *q, int sz) {
+ return do_merge_outs(p,q) ;
+}
+
+int same_outs(outs_t *p,outs_t *q) {
+ while (p && q) {
+ if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;
+ if (!same_outs(p->down,q->down)) return 0 ;
+ p = p->next ;
+ q = q->next ;
+ }
+ return p == q ; /* == NULL */
+}
diff --git a/tests/tcg/i386/litmus/outs.h b/tests/tcg/i386/litmus/outs.h
new file mode 100644
index 0000000..761590f
--- /dev/null
+++ b/tests/tcg/i386/litmus/outs.h
@@ -0,0 +1,49 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _OUTS_H
+#define _OUTS_H 1
+
+#include <stdio.h>
+
+/************************/
+/* Histogram structure */
+/************************/
+
+
+/* 64bit counters, should be enough! */
+#include <inttypes.h>
+typedef uint64_t count_t;
+#define PCTR PRIu64
+
+
+
+
+typedef struct outs_t {
+ struct outs_t *next,*down ;
+ count_t c ;
+ intmax_t k ;
+ int show ;
+} outs_t ;
+
+void free_outs(outs_t *p) ;
+outs_t *add_outcome_outs(outs_t *p, intmax_t *o, int sz, count_t v, int show) ;
+int finals_outs(outs_t *p) ;
+count_t sum_outs(outs_t *p) ;
+typedef void dump_outcome(FILE *chan, intmax_t *o, count_t c, int show) ;
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int sz) ;
+outs_t *merge_outs(outs_t *p,outs_t *q, int sz) ;
+int same_outs(outs_t *p,outs_t *q) ;
+#endif
diff --git a/tests/tcg/i386/litmus/run.sh b/tests/tcg/i386/litmus/run.sh
new file mode 100755
index 0000000..190e36c
--- /dev/null
+++ b/tests/tcg/i386/litmus/run.sh
@@ -0,0 +1,55 @@
+date
+LITMUSOPTS="${@:-$LITMUSOPTS}"
+SLEEP=0
+if [ ! -f SAL.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for x86.tests/SAL.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+X86 SAL
+"Fre PodWR Fre PodWR"
+
+{x=0; y=0;}
+
+ P0 | P1 ;
+ MOV [x],$1 | MOV [y],$1 ;
+ MFENCE | MFENCE ;
+ MOV EAX,[y] | MOV EAX,[x] ;
+
+~exists (0:EAX=0 /\ 1:EAX=0)
+Generated assembler
+EOF
+cat SAL.t
+$QEMU ./SAL.exe -q $LITMUSOPTS
+ret=$?;
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit $ret;
+fi
+fi
+sleep $SLEEP
+
+cat <<'EOF'
+Revision exported, version 7.22
+Command line: ../litmus-7.22/litmus -exit true -mach ../alex_litmus/overdrive01 -o run.x86 x86.tests/SAL.litmus
+Parameters
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+/* gcc options: -D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -fomit-frame-pointer -O2 -pthread */
+/* barrier: user */
+/* launch: changing */
+/* affinity: incr0 */
+/* alloc: dynamic */
+/* memory: direct */
+/* stride: 1 */
+/* safer: write */
+/* preload: random */
+/* speedcheck: no */
+/* proc used: 0 */
+EOF
+head -1 comp.sh
+echo "LITMUSOPTS=$LITMUSOPTS"
+date
diff --git a/tests/tcg/i386/litmus/show.awk b/tests/tcg/i386/litmus/show.awk
new file mode 100644
index 0000000..c8ecf20
--- /dev/null
+++ b/tests/tcg/i386/litmus/show.awk
@@ -0,0 +1,2 @@
+/START _litmus_P/ { print $0 }
+/_litmus_P[0-9]+_[0-9]+/ { getline; print $0 ; }
diff --git a/tests/tcg/i386/litmus/utils.c b/tests/tcg/i386/litmus/utils.c
new file mode 100644
index 0000000..cc989b0
--- /dev/null
+++ b/tests/tcg/i386/litmus/utils.c
@@ -0,0 +1,1148 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include "utils.h"
+
+/********/
+/* Misc */
+/********/
+
+FILE *errlog ;
+
+static void checkerrlog(void) {
+ if (!errlog) errlog = stderr ;
+}
+
+void seterrlog(FILE *chan) {
+ errlog = chan ;
+}
+
+int log_error(const char *fmt, ...) {
+ int result;
+ va_list args;
+ va_start(args, fmt);
+ checkerrlog() ;
+ result = vfprintf(errlog, fmt, args);
+ fflush(errlog);
+ va_end(args);
+ return result;
+}
+
+void fatal(char *msg) {
+ log_error("Failure: %s\n", msg) ;
+ fclose(errlog);
+ fprintf(stdout,"Failure: %s\n", msg) ;
+ exit(1) ;
+}
+
+void errexit(char *msg,int err) {
+ log_error("%s: %s\n",msg,strerror(err)) ;
+ fclose(errlog);
+ exit(2) ;
+}
+
+void *malloc_check(size_t sz) {
+ if (sz == 0) return NULL ;
+ void *p = malloc(sz) ;
+ if (!p) {
+ if (!errno) errno = ENOMEM ;
+ errexit("malloc",errno) ;
+ }
+ return p ;
+}
+
+int max(int n, int m) { return n < m ? m : n ; }
+
+void pp_ints(FILE *fp,int *p,int n) {
+ if (n > 0) {
+ fprintf(fp,"%i",p[0]) ;
+ for (int k = 1 ; k < n ; k++) {
+ fprintf(fp,",%i",p[k]) ;
+ }
+ }
+}
+
+
+void *do_align(void *p,size_t sz) {
+ uintptr_t x = (uintptr_t)p ;
+ x += sz-1 ;
+ x /= sz ;
+ x *= sz ;
+ return (void *)x ;
+}
+
+void *do_noalign(void *p,size_t sz) {
+ void *q = do_align(p,sz) ;
+ void *r = q - sz/2 ;
+ if (r < p) r = q + sz/2 ;
+ return r ;
+}
+
+void cat_file(char *path, char *msg, FILE *out) {
+ FILE *fp = fopen(path,"r") ;
+ if (fp == NULL) return ;
+ fprintf(out,"%s\n",msg) ;
+ int c,nl=1 ;
+ while ((c = fgetc(fp)) != EOF) {
+ fputc(c,out) ;
+ nl = c == '\n' ;
+ }
+ fclose(fp) ;
+ if (!nl) fputc('\n',out) ;
+}
+
+/************/
+/* CPU sets */
+/************/
+
+cpus_t *cpus_create(int sz) {
+ cpus_t *r = malloc_check(sizeof(*r)) ;
+ r->sz = sz ;
+ r->cpu = malloc_check(sizeof(r->cpu[0])*sz) ;
+ return r ;
+}
+
+cpus_t *cpus_create_init(int sz, int t[]) {
+ cpus_t *r = cpus_create(sz) ;
+ for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;
+ return r ;
+}
+
+void cpus_free(cpus_t *p) {
+ free(p->cpu) ;
+ free(p) ;
+}
+
+void cpus_dump(FILE *fp, cpus_t *p) {
+ pp_ints(fp,p->cpu,p->sz) ;
+}
+
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {
+ for (int k = 0 ; k < sz ; k += nprocs) {
+ fprintf(fp,"[") ;
+ pp_ints(fp,&p[k],nprocs) ;
+ fprintf(fp,"] {") ;
+ if (nprocs > 0) {
+ fprintf(fp,"%i",cm->cpu[p[k]]) ;
+ for (int i = 1 ; i < nprocs ; i++) {
+ fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
+ }
+ }
+ fprintf(fp,"}\n") ;
+ }
+}
+
+/*************/
+/* Int array */
+/*************/
+
+
+void ints_dump(FILE *fp, ints_t *p) {
+ if (p->sz > 0) {
+ fprintf(fp,"%i:%i",0,p->t[0]) ;
+ for (int k = 1 ; k < p->sz ; k++) {
+ fprintf(fp,",%i:%i",k,p->t[k]) ;
+ }
+ }
+}
+
+/***********************/
+/* Prefetch directives */
+/***********************/
+void prefetch_dump(FILE *fp, prfdirs_t *p) {
+ prfproc_t *q = p->t ;
+ int some = 0 ;
+ for (int _p = 0 ; _p < p->nthreads ; _p++) {
+ int nvars = q[_p].nvars ;
+ prfone_t *r = q[_p].t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ prfdir_t dir = r[_v].dir ;
+ if (dir != none) {
+ char c = 'I' ;
+ if (dir == flush) c = 'F' ;
+ else if (dir == touch) c = 'T' ;
+ else if (dir == touch_store) c = 'W' ;
+ if (some) {
+ fprintf(fp,",") ;
+ } else {
+ some = 1 ;
+ }
+ fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
+ }
+ }
+ }
+}
+
+static void set_prefetch(prfdirs_t *p, prfdir_t d) {
+ prfproc_t *q = p->t ;
+ for (int _p = 0 ; _p < p->nthreads ; _p++) {
+ int nvars = q[_p].nvars ;
+ prfone_t *r = q[_p].t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ r[_v].dir = d ;
+ }
+ }
+}
+
+/* ??? */
+
+int gcd(int a, int b) {
+ for ( ; ; ) {
+ if (a == 0) return b ;
+ int tmp = a ;
+ a = b % a ;
+ b = tmp ;
+ }
+}
+
+/* SMT description */
+
+
+cpus_t *coremap_seq(int navail, int nways) {
+ cpus_t *r = cpus_create(navail) ;
+ int ncores = navail / nways ;
+ int i = 0 ;
+ for (int c = 0 ; c < ncores ; c++) {
+ for (int k = 0 ; k < nways ; k++) {
+ r->cpu[i++] = c ;
+ }
+ }
+ return r ;
+}
+
+cpus_t *coremap_end(int navail, int nways) {
+ cpus_t *r = cpus_create(navail) ;
+ int ncores = navail / nways ;
+ int i = 0 ;
+ for (int k = 0 ; k < nways ; k++) {
+ for (int c = 0 ; c < ncores ; c++) {
+ r->cpu[i++] = c ;
+ }
+ }
+ return r ;
+}
+
+typedef struct {
+ int ncores ;
+ cpus_t **core ;
+} mapcore_t ;
+
+
+static void mapcore_free(mapcore_t *p) {
+ for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;
+ free(p->core) ;
+ free(p) ;
+}
+
+#if 0
+static mapcore_t *inverse_coremap(cpus_t *p, int nways) {
+ mapcore_t *r = malloc_check(sizeof(*r)) ;
+ r->ncores = p->sz / nways ;
+ r->core = malloc_check(r->ncores * sizeof(r->core[0])) ;
+ for (int k = 0 ; k < r->ncores ; k++) {
+ r->core[k] = cpus_create(nways) ;
+ r->core[k]->sz = 0 ;
+ }
+ for (int k = 0 ; k < p->sz ; k++) {
+ int c = p->cpu[k] ;
+ cpus_t *q = r->core[c] ;
+ q->cpu[q->sz++] = k ;
+ }
+ return r ;
+}
+#endif
+
+static int get_ncores(cpus_t *cm) {
+ int r = 0;
+ for (int k = 0 ; k < cm->sz ; k++) {
+ if (cm->cpu[k] > r) r = cm->cpu[k] ;
+ }
+ return r+1 ;
+}
+
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {
+ int sz = 0 ;
+ cpus_t *r ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ if (cm->cpu[p->cpu[k]] == c) sz++ ;
+ }
+ r = cpus_create(sz) ;
+ int i = 0 ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ int proc = p->cpu[k] ;
+ if (cm->cpu[proc] == c) r->cpu[i++] = proc ;
+ }
+ return r ;
+}
+
+static mapcore_t *inverse_procs(cpus_t *cm, cpus_t *p) {
+ int ncores = get_ncores(cm) ;
+ mapcore_t *r = malloc_check(sizeof(*r)) ;
+ r->ncores = ncores ;
+ r->core = malloc_check(sizeof(r->core[0])*ncores) ;
+ for (int c = 0 ; c < ncores ; c++) {
+ r->core[c] = get_core_procs(cm,p,c) ;
+ }
+ return r ;
+}
+
+static int get_node_sz(int *p) {
+ int r = 0 ;
+ while (*p++ >= 0) r++ ;
+ return r ;
+}
+
+static int get_n(int **p) {
+ int r = 0 ;
+ while (*p) {
+ r += get_node_sz(*p) ;
+ p++ ;
+ }
+ return r ;
+}
+
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
+ for (int k = 0 ; k < n ; k++) {
+ int op = a[k] ;
+ if (op >= 0) {
+ if (d[n*p+k]) {
+ int oc = cm[op] ;
+ if (oc == c) {
+ return 0 ;
+ }
+ }
+ }
+ }
+ return 1 ;
+}
+
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
+ for ( ; *q >= 0 ; q++) {
+ if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
+ }
+ return 1 ;
+}
+
+static int find_color_diff
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
+ int sz = get_node_sz(q) ;
+ int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
+ int k = k0 ;
+ do {
+ cpus_t *p = mc->core[k] ;
+ if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
+ k++ ; k %= mc->ncores ;
+ } while (k != k0) ;
+ return -1 ;
+}
+
+
+static int find_one_proc
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
+ int found = -1 ;
+ int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
+ int k = k0 ;
+ do {
+ cpus_t *pk = mc->core[k] ;
+ if (pk->sz > 0) {
+ if (found < 0) found = k ;
+ if (ok_one_color(cm,d,a,n,p,k)) return k ;
+ }
+ k++ ; k %= mc->ncores ;
+ } while (k != k0) ;
+ if (found < 0) fatal("Cannot allocate threads") ;
+ return found ;
+}
+
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) {
+ mapcore_t *mc = inverse_procs(cm,aff_cpus) ;
+ int n = get_n(color) ;
+ /* Diff relation as matrix */
+ int d[n*n] ;
+ {
+ int *q = diff ;
+ for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;
+ while (*q >= 0) {
+ int x = *q++, y = *q++ ;
+ d[n*x+y] = d[n*y+x] = 1 ;
+ }
+ }
+ for (int k = 0 ; k < n_exe ; k++) {
+ int *a = &r[k*n] ;
+ int prev_core = -1 ;
+ for (int i = 0 ; i < n ; i++) a[i] = -1 ;
+ for (int **q = color ; *q ; q++) {
+ int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
+ if (c >= 0) {
+ cpus_t *p = mc->core[c] ;
+ for (int *qq = *q ; *qq >= 0 ; qq++) {
+ p->sz-- ;
+ a[*qq] = p->cpu[p->sz] ;
+ }
+ prev_core = c ;
+ } else {
+ for (int *qq = *q ; *qq >= 0 ; qq++) {
+ int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
+ cpus_t *p = mc->core[c] ;
+ p->sz-- ;
+ a[*qq] = p->cpu[p->sz] ;
+ prev_core = c ;
+ }
+ }
+ }
+ }
+ mapcore_free(mc) ;
+}
+
+/****************/
+/* Command line */
+/****************/
+
+/* usage */
+
+static void usage(char *prog, cmd_t *d) {
+ log_error("usage: %s (options)*\n",prog) ;
+ log_error(" -v be verbose\n") ;
+ log_error(" -q be quiet\n") ;
+ log_error(" -a <n> run maximal number of tests for n available processors (default %i)\n",d->avail) ;
+ log_error(" -n <n> run n tests concurrently\n") ;
+ log_error(" -r <n> perform n runs (default %i)\n",d->max_run) ;
+ log_error(" -fr <f> multiply run number per f\n") ;
+ log_error(" -s <n> outcomes per run (default %i)\n",d->size_of_test) ;
+ if (d->stride > 0) {
+ log_error(" -st <n> stride (default %i)\n",d->stride) ;
+ }
+ log_error(" -fs <f> multiply outcomes per f\n") ;
+ log_error(" -f <f> multiply outcomes per f, divide run number by f\n") ;
+ if (d->aff_mode != aff_none) {
+ log_error(" -i <n> increment for allocating logical processors, -i 0 disables affinity mode") ;
+ if (d->aff_mode == aff_incr) {
+ log_error(" (default %i)\n",d->aff_incr) ;
+ } else {
+ log_error("\n") ;
+ }
+ log_error(" -p <ns> specify logical processors (default '") ;
+ cpus_dump(errlog,d->aff_cpus) ;
+ log_error("')\n") ;
+ log_error(" +ra randomise affinity%s\n",d->aff_mode == aff_random ? " (default)" : "") ;
+ if (d->aff_custom_enabled) {
+ log_error(" +ca enable custom affinity%s\n",d->aff_mode == aff_custom ? " (default)" : "") ;
+ } else {
+ log_error(" +ca alias for +ra\n") ;
+ }
+ if (d->aff_scan_enabled) {
+ log_error(" +sa enable scanning affinity%s\n",d->aff_mode == aff_scan ? " (default)" : "") ;
+ log_error(" +ta <topo> set topology affinity\n") ;
+ } else {
+ log_error(" +sa alias for +ra\n") ;
+ }
+ }
+ if (d->shuffle >= 0) {
+ log_error(" +rm randomise memory accesses%s\n",d->shuffle ? " (default)" : "") ;
+ log_error(" -rm do not randomise memory accesses%s\n",!d->shuffle ? " (default)" : "") ;
+ }
+ if (d->speedcheck >= 0) {
+ log_error(" +sc stop as soon as possible%s\n",d->speedcheck ? " (default)" : "") ;
+ log_error(" -sc run test completly%s\n",!d->speedcheck ? " (default)" : "") ;
+ }
+ if (!d->fix) {
+ log_error(" +fix fix thread launch order\n") ;
+ }
+ if (d->delta_tb) {
+ log_error(" -tb <list> set timebase delays, default '") ;
+ ints_dump(errlog,d->delta_tb) ;
+ log_error("'\n") ;
+ log_error(" List syntax is comma separated proc:delay\n") ;
+ log_error(" -ta <n> set all timebase delays\n") ;
+ }
+ if (d->verbose_barrier >= 0) {
+ log_error(" +vb show iteration timings%s\n",d->verbose_barrier ? " (default)" : "") ;
+ log_error(" -vb do not show iteration timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
+ }
+ if (d->prefetch) {
+ log_error(" -pra (I|F|T|W) set all prefetch\n") ;
+ log_error(" -prf <list> set prefetch, default '") ;
+ prefetch_dump(errlog,d->prefetch) ;
+ log_error("'\n") ;
+ log_error(" List syntax is comma separated proc:name=(I|F|T|W)\n") ;
+ }
+ if (d->static_prefetch >= 0) {
+ log_error(" -prs <n> prefetch probability is 1/n, -prs 0 disables feature, default %i\n",d->static_prefetch) ;
+ }
+ if (d->max_loop > 0) {
+ log_error(" -l <n> measure time by running assembly in a loop of size <n> (default %i)\n",d->max_loop) ;
+ }
+ if (d->prelude > 0) {
+ log_error(" -vp no verbose prelude\n") ;
+ }
+ if (d->sync_n > 0) {
+ log_error(" -k <n> undocumented (default %i)\n",d->sync_n) ;
+ }
+ exit(2) ;
+}
+
+static long my_add (long x, long y) {
+ long r = x+y ;
+ if (r < x || r < y) { errno = ERANGE ; fatal("overflow") ; }
+ return r ;
+}
+
+static long my_pow10(int p,long x) {
+ long r = x ;
+ for ( ; p > 0 ; p--) {
+ long y2 = my_add(r,r) ;
+ long y4 = my_add(y2,y2) ;
+ long y8 = my_add(y4,y4) ;
+ r = my_add(y8,y2) ;
+ }
+ if (r >= INT_MAX || r <= 0) { errno = ERANGE ; fatal("overflow") ; }
+ return r ;
+}
+
+static int do_argint(char *p, char **q) {
+ long r = strtol(p,q,10) ;
+ if (errno == ERANGE) { fatal("overflow") ; }
+ 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 ; }
+ return (int)r ;
+}
+
+static int argint(char *prog,char *p,cmd_t *d) {
+ char *q ;
+ long r = do_argint(p,&q) ;
+ if (*p == '\0' || *q != '\0') {
+ usage(prog,d) ;
+ }
+ return (int)r ;
+}
+
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
+ int sz = 0 ;
+ char *p ;
+
+ p = p0 ;
+ for ( ; ; ) {
+ char *q ;
+ int x = (int)strtol(p,&q,10) ;
+ if (x < 0 || *p == '\0' || (*q != '\0' && *q != ',')) usage(prog,d) ;
+ sz++ ;
+ if (*q == '\0') break ;
+ p = q+1 ;
+ }
+ cpus_t *r = cpus_create(sz) ;
+ p = p0 ;
+ for (int k = 0 ; k < sz ; k++) {
+ char *q ;
+ r->cpu[k] = (int)strtol(p,&q,10) ;
+ p = q+1 ;
+ }
+ return r ;
+}
+
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
+ while (*p) {
+ char *q ;
+ int idx = (int)strtol(p,&q,10) ;
+ if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':') usage(prog,d) ;
+ p = q+1 ;
+ int v = do_argint(p,&q) ;
+ if (*p == '\0' || (*q != '\0' && *q != ',')) usage(prog,d) ;
+ r->t[idx] = v ;
+ if (*q == '\0') {
+ p = q ;
+ } else {
+ p = q+1 ;
+ }
+ }
+}
+
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {
+ int nvars = p->nvars ;
+ prfone_t *q = p->t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
+ }
+ return NULL ; /* Name not found */
+}
+
+
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
+ prfdir_t dir = none ;
+ switch (*p) {
+ case 'F':
+ dir = flush ;
+ break ;
+ case 'T':
+ dir = touch ;
+ break ;
+ case 'W':
+ dir = touch_store ;
+ break ;
+ }
+ set_prefetch(r,dir) ;
+}
+
+int parse_prefetch(char *p, prfdirs_t *r) {
+ if (!*p) return 1 ;
+ for ( ;; ) {
+ char *q ;
+ int proc = (int)strtol(p,&q,10) ;
+ if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
+ return 0 ;
+ p = q+1 ;
+ char *p0 = p ;
+ while (*p != '=') {
+ if (*p == '\0') return 0 ;
+ p++ ;
+ }
+ *p = '\0' ;
+ prfone_t *loc_slot = get_name_slot(&r->t[proc],p0) ;
+ if (loc_slot == NULL) {
+ log_error("Proc %i does not access variable %s\n",proc,p0) ;
+ *p = '=' ;
+ return 0 ;
+ }
+ *p = '=' ;
+ char c = *++p;
+ prfdir_t dir = none ;
+ switch (c) {
+ case 'F':
+ dir = flush ;
+ break ;
+ case 'T':
+ dir = touch ;
+ break ;
+ case 'W':
+ dir = touch_store ;
+ break ;
+ }
+ loc_slot->dir = dir ;
+ c = *++p ;
+ if (c == '\0') return 1 ;
+ else if (c == ',') p++ ;
+ else return 0 ;
+ }
+}
+
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
+ if (!parse_prefetch(p,r)) usage(prog,d) ;
+}
+
+static double argdouble(char *prog,char *p,cmd_t *d) {
+ char *q ;
+ double r = strtod(p,&q) ;
+ if (*p == '\0' || *q != '\0') {
+ usage(prog,d) ;
+ }
+ return r ;
+}
+
+void parse_cmd(int argc, char **argv, cmd_t *d, cmd_t *p) {
+ char *prog = argv[0] ;
+
+ /* Options */
+ for ( ; ; ) {
+ --argc ; ++argv ;
+ if (!*argv) break ;
+ char fst = **argv ;
+ if (fst != '-' && fst != '+') break ;
+ if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
+ else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
+ else if (strcmp(*argv,"-r") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->max_run = argint(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-fr") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->max_run *= argdouble(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-s") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->size_of_test = argint(prog,argv[0],d) ;
+ } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->stride = argint(prog,argv[0],d) ;
+ if (p->stride <= 0) p->stride = 1 ;
+ } else if (strcmp(*argv,"-fs") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->size_of_test *= argdouble(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-f") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ double f = argdouble(prog,argv[0],d) ;
+ p->size_of_test *= f ;
+ p->max_run /= f ;
+ } else if (strcmp(*argv,"-n") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->n_exe = argint(prog,argv[0],d) ;
+ if (p->n_exe < 1) p->n_exe = 1 ;
+ } else if (strcmp(*argv,"-a") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int a = argint(prog,argv[0],d) ;
+ p->avail = a ;
+ } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int a = argint(prog,argv[0],d) ;
+ p->sync_n = a < 0 ? 0 : a ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int i = argint(prog,argv[0],d) ;
+ p->aff_mode = aff_incr ;
+ p->aff_incr = i < 0 ? 0 : i ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ cpus_t *cpus = argcpus(prog,argv[0],d) ;
+ p->aff_cpus = cpus ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
+ p->aff_mode = aff_custom ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_scan ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
+ p->aff_mode = aff_topo ;
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->aff_topo = argv[0] ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
+ p->shuffle = 1 ;
+ } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
+ p->shuffle = 0 ;
+ } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
+ p->speedcheck = 1 ;
+ } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
+ p->speedcheck = 0 ;
+ } else if (!d->fix && strcmp(*argv,"+fix") == 0) {
+ p->fix = 1 ;
+ } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
+ p->verbose_barrier++ ;
+ } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
+ p->verbose_barrier = 0 ;
+ } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
+ p->prelude = 0 ;
+ } else if (d->delta_tb && strcmp(*argv,"-tb") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argints(prog,d,argv[0],p->delta_tb) ;
+ } else if (d->delta_tb && strcmp(*argv,"-ta") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int da = argint(prog,argv[0],d) ;
+ for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;
+ } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argprefetch(prog,d,argv[0],p->prefetch) ;
+ } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argoneprefetch(prog,d,argv[0],p->prefetch) ;
+ } else if (d->static_prefetch >= 0 && strcmp(*argv,"-prs") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int prs = argint(prog,argv[0],d) ;
+ p->static_prefetch = prs >= 0 ? prs : 0 ;
+ } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int i = argint(prog,argv[0],d) ;
+ p->max_loop = i < 1 ? 1 : i ;
+ } else usage(prog,d) ;
+ }
+
+ /* Argument */
+ if (argc == 0) return ;
+ usage(prog,d) ;
+}
+
+/*************************/
+/* Concurrency utilities */
+/*************************/
+
+/* phread based mutex */
+
+pm_t *pm_create(void) {
+ pm_t *p = malloc_check(sizeof(*p)) ;
+ int ret = pthread_mutex_init(p,NULL) ;
+ if (ret) { errexit("mutex_init",ret) ; }
+ return p ;
+}
+
+void pm_free(pm_t *p) {
+ free(p) ;
+}
+
+void pm_lock(pm_t *m) {
+ int ret = pthread_mutex_lock(m) ;
+ if (ret) { errexit("mutex_lock",ret) ; }
+}
+
+void pm_unlock(pm_t *m) {
+ int ret = pthread_mutex_unlock(m) ;
+ if (ret) { errexit("mutex_unlock",ret) ; }
+}
+
+/* phread condition */
+
+pc_t *pc_create(void) {
+ pc_t *p = malloc_check(sizeof(*p)) ;
+ p->c_mutex = pm_create() ;
+ p->c_cond = malloc_check(sizeof(*(p->c_cond))) ;
+ int e = pthread_cond_init(p->c_cond,NULL) ;
+ if (e) { errexit("cond_init",e); }
+ return p ;
+}
+
+void pc_free(pc_t *p) {
+ pm_free(p->c_mutex) ;
+ free(p->c_cond) ;
+ free(p) ;
+}
+
+static void pc_lock(pc_t *p) {
+ pm_lock(p->c_mutex) ;
+}
+
+static void pc_unlock(pc_t *p) {
+ pm_unlock(p->c_mutex) ;
+}
+
+void pc_wait(pc_t *p) {
+ int e = pthread_cond_wait(p->c_cond, p->c_mutex) ;
+ if (e) { errexit("cond_wait",e) ; }
+}
+
+void pc_broadcast (pc_t *p) {
+ int e = pthread_cond_broadcast(p->c_cond) ;
+ if (e) { errexit("cond_broadcast",e) ; }
+}
+
+static void pc_signal(pc_t *p) {
+ int e = pthread_cond_signal(p->c_cond);
+ if (e) errexit("cond_signal",e) ;
+}
+
+
+/* pthread based barrier, usable for nproc threads */
+
+
+pb_t *pb_create(int nprocs) {
+ pb_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->count = p->nprocs = nprocs ;
+ p->turn = 0 ;
+ return p ;
+}
+
+void pb_free(pb_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+/* The following code should protect us against spurious wake ups */
+void pb_wait(pb_t *p) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ pc_unlock(p->cond) ;
+}
+
+
+/* pthread based or flag */
+
+po_t *po_create(int nprocs) {
+ po_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->nprocs = p->count = nprocs ;
+ p->val = 0 ;
+ p->turn = 0 ;
+ return p ;
+}
+
+void po_free(po_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+void po_reinit(po_t *p) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->val = 0 ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ pc_unlock(p->cond) ;
+}
+
+int po_wait(po_t *p, int v) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ p->val = p->val || v ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ int r = p->val ;
+ pc_unlock(p->cond) ;
+ return r ;
+}
+
+
+/* One place buffer */
+
+op_t *op_create(void) {
+ op_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->val = NULL ;
+ p->some = 0 ;
+ return p;
+}
+
+void op_free(op_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+void op_set(op_t *p, void *v) {
+ pc_lock(p->cond) ;
+ if (p->some) { fatal("op_set") ; }
+ p->val = v ;
+ p->some = 1 ;
+ pc_signal(p->cond) ;
+ pc_unlock(p->cond) ;
+}
+
+void *op_get(op_t *p) {
+ void *v = NULL ;
+ pc_lock(p->cond) ;
+ while (!p->some) {
+ pc_wait(p->cond) ;
+ }
+ v = (void *) p->val ;
+ p->val = NULL ;
+ p->some = 0 ;
+ pc_unlock(p->cond) ;
+ return v ;
+}
+
+/* Thread launch and join */
+
+void launch(pthread_t *th, f_t *f, void *a) {
+ int e = pthread_create(th,NULL,f,a);
+ if (e) errexit("phread_create",e);
+}
+
+void *join(pthread_t *th) {
+ void *r ;
+ int e = pthread_join(*th,&r) ;
+ if (e) errexit("pthread_join",e);
+ return r ;
+}
+
+/* Detached */
+
+typedef struct {
+ f_t *f;
+ void *a ;
+ op_t *op;
+} detarg_t ;
+
+static void *zyva_det(void *_b) {
+ detarg_t *b = (detarg_t *)_b;
+ f_t *f = b->f ;
+ void *a = b->a ;
+ op_t *op = b->op ;
+ free(b) ;
+ int e = pthread_detach(pthread_self());
+ if (e) errexit("pthread_detach",e) ;
+ void *r = f(a) ;
+ op_set(op,r) ;
+ return NULL ;
+}
+
+op_t *launch_detached(f_t *f,void *a) {
+ op_t *op = op_create() ;
+ detarg_t *b = malloc_check(sizeof(*b)) ;
+ b->f = f ; b->a = a; b->op = op ;
+ pthread_t th ;
+ launch(&th,zyva_det,b) ;
+ return op ;
+}
+
+void *join_detached(op_t *op) {
+ void *r = op_get(op) ;
+ op_free(op) ;
+ return r ;
+}
+
+/* Thread cache */
+
+void *start_thread(void *_a) {
+ sarg_t *_b = (sarg_t *)_a ;
+ for (int _k = _b->max_run ; _k > 0 ; _k--) {
+ void *_c = op_get(_b->op_arg) ;
+ f_t *f = (f_t *)_c ;
+ if (f == NULL) break ;
+ void *ret = f(_b->arg) ;
+ op_set(_b->op_ret,ret) ;
+ }
+ return NULL ;
+}
+
+/*****************/
+/* Random things */
+/*****************/
+
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {
+ int k;
+ for (k = 0 ; k < m ; k++) {
+ int j = k+rand_k(st,n-k);
+ int x = _t[k]; _t[k] = _t[j]; _t[j] = x;
+ }
+}
+
+void perm_ints(unsigned *st,int *_t, int n) {
+ perm_prefix_ints(st, _t,n-1,n) ;
+}
+
+void perm_funs(unsigned *st,f_t *fun[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ f_t *t = fun[j];
+ fun[j] = fun[k]; fun[k] = t;
+ }
+}
+
+void perm_ops(unsigned *st,op_t *op[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ op_t *t = op[j];
+ op[j] = op[k]; op[k] = t;
+ }
+}
+
+void perm_threads(unsigned *st,pthread_t thread[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ pthread_t t = thread[j];
+ thread[j] = thread[k]; thread[k] = t;
+ }
+}
+
+static int int_cmp(const void *_p, const void *_q) {
+ int x = *((int *)_p) ;
+ int y = *((int *)_q) ;
+ if (x < y) return -1 ;
+ else if (x > y) return 1 ;
+ else return 0 ;
+}
+
+int check_shuffle(int **t, int *min, int sz) {
+ int *idx = malloc_check(sizeof(*idx)*sz) ;
+ for (int k=0 ; k < sz ; k++) {
+ idx[k] = (int)(t[k] - min) ;
+ // fprintf(stderr," %i",idx[k]) ;
+ }
+ // fprintf(stderr,"\n") ;
+ qsort(&idx[0],sz, sizeof(idx[0]), int_cmp) ;
+ for (int k=0 ; k < sz ; k++) {
+ if (idx[k] != k) {
+ free(idx) ;
+ return 0 ;
+ }
+ }
+ free(idx) ;
+ return 1 ;
+}
+
+/****************/
+/* Time counter */
+/****************/
+
+#include <sys/time.h>
+#include <time.h>
+
+tsc_t timeofday(void) {
+ struct timeval tv ;
+ if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
+ return tv.tv_sec * ((tsc_t)1000000) + tv.tv_usec ;
+}
+
+double tsc_ratio(tsc_t t1, tsc_t t2) {
+ return ((double) t1) / ((double)t2) ;
+}
+
+
+double tsc_millions(tsc_t t) {
+ return t / 1000000.0 ;
+}
+
+/*******************/
+/* String handling */
+/*******************/
+
+int find_string(char *t[], int sz, char *s) {
+ for (int k = 0 ; k < sz ; k++) {
+ if (strcmp(t[k],s) == 0) return k ;
+ }
+ return -1 ;
+}
diff --git a/tests/tcg/i386/litmus/utils.h b/tests/tcg/i386/litmus/utils.h
new file mode 100644
index 0000000..99e756e
--- /dev/null
+++ b/tests/tcg/i386/litmus/utils.h
@@ -0,0 +1,275 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _UTILS_H
+#define _UTILS_H 1
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include "litmus_rand.h"
+
+
+/********/
+/* Misc */
+/********/
+
+void seterrlog(FILE *chan) ;
+
+int log_error(const char *fmt,...) ;
+
+void fatal(char *msg) ;
+/* e is errno */
+void errexit(char *msg,int e) ;
+
+void *malloc_check(size_t sz) ;
+
+int max(int n,int m) ;
+
+void pp_ints (FILE *fp,int *p,int n) ;
+
+void *do_align(void *p, size_t sz) ;
+
+void *do_noalign(void *p, size_t sz) ;
+
+void cat_file(char *path,char *msg,FILE *out) ;
+
+/***********/
+/* CPU set */
+/***********/
+
+#define CPUS_DEFINED 1
+typedef struct {
+ int sz ;
+ int *cpu ;
+} cpus_t ;
+
+cpus_t *cpus_create(int sz) ;
+cpus_t *cpus_create_init(int sz, int t[]) ;
+void cpus_free(cpus_t *p) ;
+void cpus_dump(FILE *fp, cpus_t *p) ;
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) ;
+
+int gcd(int a, int b) ;
+
+cpus_t *coremap_seq(int navail, int nways) ;
+cpus_t *coremap_end(int navail, int nways) ;
+
+void custom_affinity
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) ;
+
+/*************/
+/* Int array */
+/*************/
+
+typedef struct {
+ int sz ;
+ int *t ;
+} ints_t ;
+
+void ints_dump(FILE *fp, ints_t *p) ;
+
+/* Prefetch directives */
+typedef enum {none, flush, touch, touch_store} prfdir_t ;
+
+typedef struct {
+ char *name ;
+ prfdir_t dir ;
+} prfone_t ;
+
+typedef struct {
+ int nvars ;
+ prfone_t *t ;
+} prfproc_t ;
+
+typedef struct {
+ int nthreads ;
+ prfproc_t *t ;
+} prfdirs_t ;
+
+void prefetch_dump(FILE *fp, prfdirs_t *p) ;
+int parse_prefetch(char *p, prfdirs_t *r) ;
+
+/************************/
+/* Command line options */
+/************************/
+typedef enum
+ { aff_none, aff_incr, aff_random, aff_custom,
+ aff_scan, aff_topo} aff_mode_t ;
+
+typedef struct {
+ int verbose ;
+ /* Test parmeters */
+ int max_run ;
+ int size_of_test ;
+ int stride ;
+ int avail ;
+ int n_exe ;
+ int sync_n ;
+ /* Affinity */
+ aff_mode_t aff_mode ;
+ int aff_custom_enabled ;
+ int aff_scan_enabled ;
+ int aff_incr ;
+ cpus_t *aff_cpus ;
+ char *aff_topo ;
+ /* indirect mode */
+ int shuffle ;
+ /* loop test */
+ int max_loop ;
+ /* time base delays */
+ ints_t * delta_tb ;
+ /* prefetch control */
+ prfdirs_t *prefetch ;
+ int static_prefetch ;
+ /* show time of synchronisation */
+ int verbose_barrier ;
+ /* Stop as soon as condition is settled */
+ int speedcheck ;
+ /* Enforce fixed launch order (ie cancel change lauch) */
+ int fix ;
+ /* Dump prelude to test output */
+ int prelude ;
+} cmd_t ;
+
+void parse_cmd(int argc, char **argv, cmd_t *def, cmd_t *p) ;
+
+
+/********************/
+/* Thread utilities */
+/********************/
+
+/* Mutex */
+
+typedef pthread_mutex_t pm_t ;
+
+pm_t *pm_create(void) ;
+void pm_free(pm_t *p) ;
+void pm_lock(pm_t *m) ;
+void pm_unlock(pm_t *m) ;
+
+/* Condition variable */
+
+typedef struct {
+ pm_t *c_mutex ;
+ pthread_cond_t *c_cond ;
+} pc_t ;
+
+pc_t *pc_create(void) ;
+void pc_free(pc_t *p) ;
+void pc_wait(pc_t *p) ;
+void pc_broadcast (pc_t *p) ;
+
+/* Barrier */
+
+/* Avoid pthread supplied barrier as they are not available in old versions */
+
+typedef struct {
+ volatile unsigned int count ;
+ volatile int turn ;
+ pc_t *cond ;
+ unsigned int nprocs ;
+} pb_t ;
+
+
+pb_t *pb_create(int nprocs) ;
+void pb_free(pb_t *p) ;
+void pb_wait(pb_t *p) ;
+
+
+/* Or flag */
+
+typedef struct {
+ pc_t *cond ;
+ int nprocs ;
+ int count ;
+ volatile int val ;
+ volatile int turn ;
+} po_t ;
+
+po_t *po_create(int nprocs) ;
+void po_free(po_t *p) ;
+/* Initialize flag, must be called by all participant */
+void po_reinit(po_t *p) ;
+/* Return the 'or' of the v arguments of all participants */
+int po_wait(po_t *p, int v) ;
+
+/* One place buffer */
+
+typedef struct {
+ pc_t *cond ;
+ int volatile some ;
+ void * volatile val ;
+} op_t ;
+
+op_t *op_create(void) ;
+void op_free(op_t *p) ;
+void op_set(op_t *p, void *v) ;
+void *op_get(op_t *p) ;
+
+/* Thread launch and join */
+
+typedef void* f_t(void *);
+
+void launch(pthread_t *th, f_t *f, void *a) ;
+
+void *join(pthread_t *th) ;
+
+/* Detached lauch and join */
+
+op_t *launch_detached(f_t *f,void *a) ;
+void *join_detached(op_t *p) ;
+
+/* Thread cache */
+
+typedef struct {
+ int max_run ;
+ op_t *op_arg,*op_ret ;
+ void *arg ;
+} sarg_t ;
+
+f_t start_thread ;
+
+/*****************/
+/* Random things */
+/*****************/
+
+/* permutations */
+
+void perm_prefix_ints(st_t *st,int t[], int used, int sz) ;
+void perm_ints(st_t *st,int t[], int sz) ;
+void perm_funs(st_t *st,f_t *t[], int sz) ;
+void perm_threads(st_t *st,pthread_t t[], int sz) ;
+void perm_ops(st_t *st,op_t *t[], int sz) ;
+
+/* check permutation */
+int check_shuffle(int **t, int *min, int sz) ;
+
+/*********************/
+/* Real time counter */
+/*********************/
+
+typedef unsigned long long tsc_t ;
+#define PTSC "%llu"
+
+/* Result in micro-seconds */
+tsc_t timeofday(void) ;
+double tsc_ratio(tsc_t t1, tsc_t t2) ;
+double tsc_millions(tsc_t t) ;
+
+/* String utilities */
+int find_string(char *t[],int sz,char *s) ;
+
+#endif
--
2.9.3
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [Qemu-devel] [PATCH v2 2/3] tests/tcg: Add aarch64 litmus tests
2016-08-20 16:28 [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 1/3] tests/tcg: Add i386 litmus test Pranith Kumar
@ 2016-08-20 16:28 ` Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 3/3] travis: Enable " Pranith Kumar
2016-08-20 21:19 ` [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests no-reply
3 siblings, 0 replies; 5+ messages in thread
From: Pranith Kumar @ 2016-08-20 16:28 UTC (permalink / raw)
To: qemu-devel; +Cc: alex.bennee
Add Aarch64 litmus tests.
Signed-off-by: Pranith Kumar <bobby.prani@gmail.com>
---
tests/tcg/aarch64/litmus/ARMARM00.c | 501 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM01.c | 504 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM02.c | 571 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM03.c | 498 +++++++++++++
tests/tcg/aarch64/litmus/ARMARM04+BIS.c | 556 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM04+TER.c | 538 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM04.c | 556 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM05.c | 553 ++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM06.c | 581 +++++++++++++++
tests/tcg/aarch64/litmus/ARMARM07+SAL.c | 497 +++++++++++++
tests/tcg/aarch64/litmus/Makefile | 53 ++
tests/tcg/aarch64/litmus/README.txt | 22 +
tests/tcg/aarch64/litmus/affinity.c | 159 ++++
tests/tcg/aarch64/litmus/affinity.h | 34 +
tests/tcg/aarch64/litmus/comp.sh | 30 +
tests/tcg/aarch64/litmus/litmus_rand.c | 64 ++
tests/tcg/aarch64/litmus/litmus_rand.h | 29 +
tests/tcg/aarch64/litmus/outs.c | 148 ++++
tests/tcg/aarch64/litmus/outs.h | 49 ++
tests/tcg/aarch64/litmus/run.sh | 378 ++++++++++
tests/tcg/aarch64/litmus/show.awk | 2 +
tests/tcg/aarch64/litmus/utils.c | 1148 +++++++++++++++++++++++++++++
tests/tcg/aarch64/litmus/utils.h | 275 +++++++
25 files changed, 8908 insertions(+)
create mode 100644 tests/tcg/aarch64/litmus/ARMARM00.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM01.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM02.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM03.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04+BIS.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04+TER.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM04.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM05.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM06.c
create mode 100644 tests/tcg/aarch64/litmus/ARMARM07+SAL.c
create mode 100644 tests/tcg/aarch64/litmus/Makefile
create mode 100644 tests/tcg/aarch64/litmus/README.txt
create mode 100644 tests/tcg/aarch64/litmus/affinity.c
create mode 100644 tests/tcg/aarch64/litmus/affinity.h
create mode 100644 tests/tcg/aarch64/litmus/comp.sh
create mode 100644 tests/tcg/aarch64/litmus/litmus_rand.c
create mode 100644 tests/tcg/aarch64/litmus/litmus_rand.h
create mode 100644 tests/tcg/aarch64/litmus/outs.c
create mode 100644 tests/tcg/aarch64/litmus/outs.h
create mode 100755 tests/tcg/aarch64/litmus/run.sh
create mode 100644 tests/tcg/aarch64/litmus/show.awk
create mode 100644 tests/tcg/aarch64/litmus/utils.c
create mode 100644 tests/tcg/aarch64/litmus/utils.h
diff --git a/tests/tcg/aarch64/litmus/ARMARM00.c b/tests/tcg/aarch64/litmus/ARMARM00.c
new file mode 100644
index 0000000..3664ef2
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM00.c
@@ -0,0 +1,501 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 2
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x2;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x2) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x2) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 2
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x2_f = 1 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x2);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x2[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM00, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM00, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#_litmus_P0_2\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P0_3\n\t"
+"stlr %w[x2],[%[x3]]\n"
+"#END _litmus_P0\n\t"
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM00");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x2 = _a->out_1_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"ldr %w[x2],[%[x3]]\n"
+"#_litmus_P1_4\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
+:[x1] "r" (&_a->y[_i]),"[x2]" (-1),[x3] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x2_i = ctx.out_1_x2[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x2_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x2_f] = _out_1_x2_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM00 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=8b05db686103708c048891dddc96e8bd\n");
+ fprintf(out,"Com=Rf Fr\n");
+ fprintf(out,"Orig=PodWWPL RfeLA PodRRAP Fre\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM00 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM00 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM00: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM00, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM00, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM01.c b/tests/tcg/aarch64/litmus/ARMARM01.c
new file mode 100644
index 0000000..4320bb0
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM01.c
@@ -0,0 +1,504 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 2
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x3) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 2
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x3_f = 1 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM01, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM01, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#_litmus_P0_2\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P0_3\n\t"
+"stlr %w[x2],[%[x3]]\n"
+"#END _litmus_P0\n\t"
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM01");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x3 = _a->out_1_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P1_4\n\t"
+"ldr %w[x3],[%[x4],%w[x2],sxtw]\n"
+"#_litmus_P1_5\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x3_i = ctx.out_1_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x3_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x3_f] = _out_1_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM01 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=e5d401d98b0063559060cb31236f54de\n");
+ fprintf(out,"Com=Rf Fr\n");
+ fprintf(out,"Orig=PodWWPL RfeLP DpAddrdR Fre\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM01 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM01 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM01: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM01, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM01, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM02.c b/tests/tcg/aarch64/litmus/ARMARM02.c
new file mode 100644
index 0000000..0846b53
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM02.c
@@ -0,0 +1,571 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 3
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x3;
+ int *out_2_x0;
+ int *out_2_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x3,int _out_2_x0,int _out_2_x3) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x3) {
+ case 0:
+ return 1;
+ default:
+ goto label00;
+ }
+ default:
+ goto label00;
+ }
+ label00: /* occs=2 */
+ switch (_out_2_x0) {
+ case 1:
+ switch (_out_2_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 4
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x3_f = 1 ;
+static const int out_2_x0_f = 2 ;
+static const int out_2_x3_f = 3 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
+ _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
+ _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x3);
+ free((void *)_a->out_2_x0);
+ free((void *)_a->out_2_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x3[_i] = -239487;
+ _a->out_2_x0[_i] = -239487;
+ _a->out_2_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM02, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM02, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#_litmus_P0_2\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P0_3\n\t"
+"stlr %w[x2],[%[x3]]\n"
+"#END _litmus_P0\n\t"
+:[x2] "=&r" (trashed_x2),[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x3 = _a->out_1_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P1_4\n\t"
+"ldr %w[x3],[%[x4],%w[x2],sxtw]\n"
+"#_litmus_P1_5\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM02");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_2_x0 = _a->out_2_x0;
+ int *out_2_x3 = _a->out_2_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P2_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P2_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P2_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P2_4\n\t"
+"ldr %w[x3],[%[x4],%w[x2],sxtw]\n"
+"#_litmus_P2_5\n"
+"0:\n"
+"#END _litmus_P2\n\t"
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x3_i = ctx.out_1_x3[_i];
+ int _out_2_x0_i = ctx.out_2_x0[_i];
+ int _out_2_x3_i = ctx.out_2_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x3_i,_out_2_x0_i,_out_2_x3_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x3_f] = _out_1_x3_i;
+ o[out_2_x0_f] = _out_2_x0_i;
+ o[out_2_x3_f] = _out_2_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM02 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X3=0 \\/ 2:X0=1 /\\ 2:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=331667937512d41933d43e7fe662a69e\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM02 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM02 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM02: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM02, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM02, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM03.c b/tests/tcg/aarch64/litmus/ARMARM03.c
new file mode 100644
index 0000000..cc7ef33
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM03.c
@@ -0,0 +1,498 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 2
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *z;
+ int* *y;
+ int *x;
+/* Final content of observed registers */
+ int* *out_1_x0;
+ int *out_1_x9;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int* _out_1_x0,int _out_1_x9,void *_val_x) {
+ return (_out_1_x0 == _val_x) && (_out_1_x9 == 0);
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+static int idx_addr(ctx_t *_a,int _i,void *v_addr) {
+ 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;}
+}
+
+static char *pretty_addr[4] = {"0","z","y","x",};
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 2
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x9_f = 1 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x9 = malloc_check(size_of_test*sizeof(*(_a->out_1_x9)));
+ _a->z = malloc_check(size_of_test*sizeof(*(_a->z)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->z);
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x9);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->z[_i] = -1;
+ _a->y[_i] = ((int *)&(_a->z[_i]));
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = NULL;
+ _a->out_1_x9[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *z = _a->z;
+ int* *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && z[_i] != -1) fatal("ARMARM03, check_globals failed");
+ if (rand_bit(&(_a->seed)) && y[_i] != ((int *)&(_a->z[_i]))) fatal("ARMARM03, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM03, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#_litmus_P0_2\n\t"
+"stlr %[x1],[%[x3]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM03");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int* *out_1_x0 = _a->out_1_x0;
+ int *out_1_x9 = _a->out_1_x9;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldr %[x0],[%[x3]]\n"
+"#_litmus_P1_1\n\t"
+"ldr %w[x9],[%[x0]]\n"
+"#END _litmus_P1\n\t"
+:[x9] "=&r" (out_1_x9[_i]),[x0] "=&r" (out_1_x0[_i])
+:[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int* _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x9_i = ctx.out_1_x9[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x9_i,&(ctx.x[_i])));
+ o[out_1_x0_f] = idx_addr(&ctx,_i,_out_1_x0_i);
+ o[out_1_x9_f] = _out_1_x9_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM03 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=x /\\ 1:X9=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=5576fb6a46ae70aa15a1087a51748a39\n");
+ fprintf(out,"Com=Rf Fr\n");
+ fprintf(out,"Orig=PodWWPL RfeLP DpAddrdR Fre\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM03 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM03 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM03: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM03, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM03, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM04+BIS.c b/tests/tcg/aarch64/litmus/ARMARM04+BIS.c
new file mode 100644
index 0000000..41a2bc4
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM04+BIS.c
@@ -0,0 +1,556 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 3
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_2_x0;
+ int *out_2_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_2_x0) {
+ case 1:
+ switch (_out_2_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 3
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_2_x0_f = 1 ;
+static const int out_2_x3_f = 2 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
+ _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_2_x0);
+ free((void *)_a->out_2_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_2_x0[_i] = -239487;
+ _a->out_2_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+BIS, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+BIS, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P1_4\n\t"
+"str %w[x2],[%[x3]]\n"
+"#_litmus_P1_5\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+BIS");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_2_x0 = _a->out_2_x0;
+ int *out_2_x3 = _a->out_2_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+ void* trashed_x5;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P2_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P2_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P2_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P2_4\n\t"
+"add %[x5],%[x4],%w[x2],sxtw\n"
+"#_litmus_P2_5\n\t"
+"ldr %w[x3],[%[x5]]\n"
+"#_litmus_P2_6\n"
+"0:\n"
+"#END _litmus_P2\n\t"
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" (trashed_x5),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_2_x0_i = ctx.out_2_x0[_i];
+ int _out_2_x3_i = ctx.out_2_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_2_x0_f] = _out_2_x0_i;
+ o[out_2_x3_f] = _out_2_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM04+BIS Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=cc1a451a55f22a8237344520956968ae\n");
+ fprintf(out,"Com=Rf Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRWAP Rfe DpAddrdRPA FreAL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM04+BIS %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM04+BIS %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM04+BIS: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM04+BIS, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM04+BIS, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM04+TER.c b/tests/tcg/aarch64/litmus/ARMARM04+TER.c
new file mode 100644
index 0000000..46dcc3a
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM04+TER.c
@@ -0,0 +1,538 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 3
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_2_x0;
+ int *out_2_x2;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x2) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_2_x0) {
+ case 1:
+ switch (_out_2_x2) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 3
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_2_x0_f = 1 ;
+static const int out_2_x2_f = 2 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
+ _a->out_2_x2 = malloc_check(size_of_test*sizeof(*(_a->out_2_x2)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_2_x0);
+ free((void *)_a->out_2_x2);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_2_x0[_i] = -239487;
+ _a->out_2_x2[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04+TER, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04+TER, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P1_2\n\t"
+"str %w[x2],[%[x3]]\n"
+"#END _litmus_P1\n\t"
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04+TER");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_2_x0 = _a->out_2_x0;
+ int *out_2_x2 = _a->out_2_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P2_1\n\t"
+"ldar %w[x2],[%[x3]]\n"
+"#END _litmus_P2\n\t"
+:[x2] "=&r" (out_2_x2[_i]),[x0] "=&r" (out_2_x0[_i])
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_2_x0_i = ctx.out_2_x0[_i];
+ int _out_2_x2_i = ctx.out_2_x2[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x2_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_2_x0_f] = _out_2_x0_i;
+ o[out_2_x2_f] = _out_2_x2_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM04+TER Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X2=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=b4e4b307db93ea419e3d73d315f6593d\n");
+ fprintf(out,"Com=Rf Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRWAP Rfe PodRRPA FreAL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM04+TER %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM04+TER %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM04+TER: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM04+TER, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM04+TER, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM04.c b/tests/tcg/aarch64/litmus/ARMARM04.c
new file mode 100644
index 0000000..c514bcd
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM04.c
@@ -0,0 +1,556 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 3
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_2_x0;
+ int *out_2_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_2_x0) {
+ case 1:
+ switch (_out_2_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 3
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_2_x0_f = 1 ;
+static const int out_2_x3_f = 2 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
+ _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_2_x0);
+ free((void *)_a->out_2_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_2_x0[_i] = -239487;
+ _a->out_2_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM04, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM04, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P1_4\n\t"
+"str %w[x2],[%[x3]]\n"
+"#_litmus_P1_5\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM04");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_2_x0 = _a->out_2_x0;
+ int *out_2_x3 = _a->out_2_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+ void* trashed_x5;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P2_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P2_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P2_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P2_4\n\t"
+"add %[x5],%[x4],%w[x2],sxtw\n"
+"#_litmus_P2_5\n\t"
+"ldar %w[x3],[%[x5]]\n"
+"#_litmus_P2_6\n"
+"0:\n"
+"#END _litmus_P2\n\t"
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x5] "=&r" (trashed_x5),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_2_x0_i = ctx.out_2_x0[_i];
+ int _out_2_x3_i = ctx.out_2_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_2_x0_f] = _out_2_x0_i;
+ o[out_2_x3_f] = _out_2_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM04 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=bd6e92e9864bd5671cb7e479e9221bae\n");
+ fprintf(out,"Com=Rf Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRWAP Rfe DpAddrdRPA FreAL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM04 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM04 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM04: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM04, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM04, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM05.c b/tests/tcg/aarch64/litmus/ARMARM05.c
new file mode 100644
index 0000000..3b80ddc
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM05.c
@@ -0,0 +1,553 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 3
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_2_x0;
+ int *out_2_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_2_x0,int _out_2_x3) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_2_x0) {
+ case 1:
+ switch (_out_2_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 3
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_2_x0_f = 1 ;
+static const int out_2_x3_f = 2 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_2_x0 = malloc_check(size_of_test*sizeof(*(_a->out_2_x0)));
+ _a->out_2_x3 = malloc_check(size_of_test*sizeof(*(_a->out_2_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_2_x0);
+ free((void *)_a->out_2_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_2_x0[_i] = -239487;
+ _a->out_2_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM05, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM05, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P1_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P1_3\n\t"
+"mov %w[x2],#1\n"
+"#_litmus_P1_4\n\t"
+"stlr %w[x2],[%[x3]]\n"
+"#_litmus_P1_5\n"
+"0:\n"
+"#END _litmus_P1\n\t"
+:[x0] "=&r" (out_1_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM05");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_2_x0 = _a->out_2_x0;
+ int *out_2_x3 = _a->out_2_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x2;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"ldr %w[x0],[%[x1]]\n"
+"#_litmus_P2_1\n\t"
+"cmp %w[x0],#1\n"
+"#_litmus_P2_2\n\t"
+"b.ne 0f\n"
+"#_litmus_P2_3\n\t"
+"eor %w[x2],%w[x0],%w[x0]\n"
+"#_litmus_P2_4\n\t"
+"ldr %w[x3],[%[x4],%w[x2],sxtw]\n"
+"#_litmus_P2_5\n"
+"0:\n"
+"#END _litmus_P2\n\t"
+:[x3] "=&r" (out_2_x3[_i]),[x0] "=&r" (out_2_x0[_i]),[x2] "=&r" (trashed_x2)
+:[x1] "r" (&_a->y[_i]),"[x3]" (-1),[x4] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_2_x0_i = ctx.out_2_x0[_i];
+ int _out_2_x3_i = ctx.out_2_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_2_x0_i,_out_2_x3_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_2_x0_f] = _out_2_x0_i;
+ o[out_2_x3_f] = _out_2_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM05 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 2:X0=1 /\\ 2:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=87598a116e95069f91ea38314a500157\n");
+ fprintf(out,"Com=Rf Rf Fr\n");
+ fprintf(out,"Orig=Rfe PodRWPL RfeLP DpAddrdR Fre\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM05 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM05 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM05: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM05, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM05, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c b/tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c
new file mode 100644
index 0000000..c44721e
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM06+AP+AA.c
@@ -0,0 +1,581 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 4
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x2;
+ int *out_3_x0;
+ int *out_3_x2;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int _out_3_x2) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x2) {
+ case 0:
+ switch (_out_3_x0) {
+ case 1:
+ switch (_out_3_x2) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 4
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x2_f = 1 ;
+static const int out_3_x0_f = 2 ;
+static const int out_3_x2_f = 3 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
+ _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
+ _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x2);
+ free((void *)_a->out_3_x0);
+ free((void *)_a->out_3_x2);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x2[_i] = -239487;
+ _a->out_3_x0[_i] = -239487;
+ _a->out_3_x2[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AA, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AA, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x2 = _a->out_1_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"ldr %w[x2],[%[x3]]\n"
+"#END _litmus_P1\n\t"
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P2_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P2\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P3(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AA");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_3_x0 = _a->out_3_x0;
+ int *out_3_x2 = _a->out_3_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P3\n"
+"#_litmus_P3_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P3_1\n\t"
+"ldar %w[x2],[%[x3]]\n"
+"#END _litmus_P3\n\t"
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2,&P3};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x2_i = ctx.out_1_x2[_i];
+ int _out_3_x0_i = ctx.out_3_x0[_i];
+ int _out_3_x2_i = ctx.out_3_x2[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x2_f] = _out_1_x2_i;
+ o[out_3_x0_f] = _out_3_x0_i;
+ o[out_3_x2_f] = _out_3_x2_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM06+AP+AA Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=09790f7c95472c70e7c2cd1b8b1f7c97\n");
+ fprintf(out,"Com=Rf Fr Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRRAP FrePL RfeLA PodRRAA FreAL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM06+AP+AA %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM06+AP+AA %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM06+AP+AA: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM06+AP+AA, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM06+AP+AA, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c b/tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c
new file mode 100644
index 0000000..7389809
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM06+AP+AP.c
@@ -0,0 +1,581 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 4
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x2;
+ int *out_3_x0;
+ int *out_3_x2;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int _out_3_x2) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x2) {
+ case 0:
+ switch (_out_3_x0) {
+ case 1:
+ switch (_out_3_x2) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 4
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x2_f = 1 ;
+static const int out_3_x0_f = 2 ;
+static const int out_3_x2_f = 3 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
+ _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
+ _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x2);
+ free((void *)_a->out_3_x0);
+ free((void *)_a->out_3_x2);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x2[_i] = -239487;
+ _a->out_3_x0[_i] = -239487;
+ _a->out_3_x2[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06+AP+AP, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06+AP+AP, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x2 = _a->out_1_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"ldr %w[x2],[%[x3]]\n"
+"#END _litmus_P1\n\t"
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P2_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P2\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P3(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06+AP+AP");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_3_x0 = _a->out_3_x0;
+ int *out_3_x2 = _a->out_3_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P3\n"
+"#_litmus_P3_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P3_1\n\t"
+"ldr %w[x2],[%[x3]]\n"
+"#END _litmus_P3\n\t"
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2,&P3};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x2_i = ctx.out_1_x2[_i];
+ int _out_3_x0_i = ctx.out_3_x0[_i];
+ int _out_3_x2_i = ctx.out_3_x2[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x2_f] = _out_1_x2_i;
+ o[out_3_x0_f] = _out_3_x0_i;
+ o[out_3_x2_f] = _out_3_x2_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM06+AP+AP Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=73c88d83e9bc423599f9750ed7d77ac2\n");
+ fprintf(out,"Com=Rf Fr Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRRAP FrePL RfeLA PodRRAP FrePL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM06+AP+AP %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM06+AP+AP %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM06+AP+AP: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM06+AP+AP, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM06+AP+AP, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM06.c b/tests/tcg/aarch64/litmus/ARMARM06.c
new file mode 100644
index 0000000..a2fa38e
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM06.c
@@ -0,0 +1,581 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 4
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_1_x0;
+ int *out_1_x2;
+ int *out_3_x0;
+ int *out_3_x2;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_1_x0,int _out_1_x2,int _out_3_x0,int _out_3_x2) {
+ switch (_out_1_x0) {
+ case 1:
+ switch (_out_1_x2) {
+ case 0:
+ switch (_out_3_x0) {
+ case 1:
+ switch (_out_3_x2) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 4
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_1_x0_f = 0 ;
+static const int out_1_x2_f = 1 ;
+static const int out_3_x0_f = 2 ;
+static const int out_3_x2_f = 3 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_1_x0 = malloc_check(size_of_test*sizeof(*(_a->out_1_x0)));
+ _a->out_1_x2 = malloc_check(size_of_test*sizeof(*(_a->out_1_x2)));
+ _a->out_3_x0 = malloc_check(size_of_test*sizeof(*(_a->out_3_x0)));
+ _a->out_3_x2 = malloc_check(size_of_test*sizeof(*(_a->out_3_x2)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_1_x0);
+ free((void *)_a->out_1_x2);
+ free((void *)_a->out_3_x0);
+ free((void *)_a->out_3_x2);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_1_x0[_i] = -239487;
+ _a->out_1_x2[_i] = -239487;
+ _a->out_3_x0[_i] = -239487;
+ _a->out_3_x2[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("ARMARM06, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("ARMARM06, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P0\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x0 = _a->out_1_x0;
+ int *out_1_x2 = _a->out_1_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P1_1\n\t"
+"ldar %w[x2],[%[x3]]\n"
+"#END _litmus_P1\n\t"
+:[x2] "=&r" (out_1_x2[_i]),[x0] "=&r" (out_1_x0[_i])
+:[x1] "r" (&_a->x[_i]),[x3] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P2(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P2\n"
+"#_litmus_P2_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P2_1\n\t"
+"stlr %w[x0],[%[x1]]\n"
+"#END _litmus_P2\n\t"
+:[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P3(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"ARMARM06");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_3_x0 = _a->out_3_x0;
+ int *out_3_x2 = _a->out_3_x2;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+asm __volatile__ (
+"\n"
+"#START _litmus_P3\n"
+"#_litmus_P3_0\n\t"
+"ldar %w[x0],[%[x1]]\n"
+"#_litmus_P3_1\n\t"
+"ldar %w[x2],[%[x3]]\n"
+"#END _litmus_P3\n\t"
+:[x2] "=&r" (out_3_x2[_i]),[x0] "=&r" (out_3_x0[_i])
+:[x1] "r" (&_a->y[_i]),[x3] "r" (&_a->x[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1,&P2,&P3};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_1_x0_i = ctx.out_1_x0[_i];
+ int _out_1_x2_i = ctx.out_1_x2[_i];
+ int _out_3_x0_i = ctx.out_3_x0[_i];
+ int _out_3_x2_i = ctx.out_3_x2[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_1_x0_i,_out_1_x2_i,_out_3_x0_i,_out_3_x2_i));
+ o[out_1_x0_f] = _out_1_x0_i;
+ o[out_1_x2_f] = _out_1_x2_i;
+ o[out_3_x0_f] = _out_3_x0_i;
+ o[out_3_x2_f] = _out_3_x2_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test ARMARM06 Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (1:X0=1 /\\ 1:X2=0 /\\ 3:X0=1 /\\ 3:X2=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=e1d155e0765dad3f8a9955c387076a95\n");
+ fprintf(out,"Com=Rf Fr Rf Fr\n");
+ fprintf(out,"Orig=RfeLA PodRRAA FreAL RfeLA PodRRAA FreAL\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation ARMARM06 %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time ARMARM06 %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "ARMARM06: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("ARMARM06, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("ARMARM06, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/ARMARM07+SAL.c b/tests/tcg/aarch64/litmus/ARMARM07+SAL.c
new file mode 100644
index 0000000..82e8c7e
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/ARMARM07+SAL.c
@@ -0,0 +1,497 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* This C source is a product of litmus7 and includes source that is */
+/* governed by the CeCILL-B license. */
+/****************************************************************************/
+/* Parameters */
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+#define N 2
+#define AFF_INCR (0)
+/* Includes */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <time.h>
+#include <limits.h>
+#include "utils.h"
+#include "outs.h"
+#include "affinity.h"
+
+/* params */
+typedef struct {
+ int verbose;
+ int size_of_test,max_run;
+ int stride;
+ aff_mode_t aff_mode;
+ int ncpus, ncpus_used;
+ int do_change;
+} param_t;
+
+
+/* Full memory barrier */
+inline static void mbar(void) {
+ asm __volatile__ ("dsb sy" ::: "memory");
+}
+
+/* Barriers macros */
+inline static void barrier_wait(unsigned int id, unsigned int k, int volatile *b) {
+ if ((k % N) == id) {
+ *b = 1 ;
+ } else {
+ while (*b == 0) ;
+ }
+}
+
+/**********************/
+/* Context definition */
+/**********************/
+
+
+typedef struct {
+/* Shared variables */
+ int *y;
+ int *x;
+/* Final content of observed registers */
+ int *out_0_x3;
+ int *out_1_x3;
+/* Check data */
+ pb_t *fst_barrier;
+/* Barrier for litmus loop */
+ int volatile *barrier;
+/* Instance seed */
+ st_t seed;
+/* Parameters */
+ param_t *_p;
+} ctx_t;
+
+inline static int final_cond(int _out_0_x3,int _out_1_x3) {
+ switch (_out_0_x3) {
+ case 0:
+ switch (_out_1_x3) {
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+inline static int final_ok(int cond) {
+ return cond;
+}
+
+/**********************/
+/* Outcome collection */
+/**********************/
+#define NOUTS 2
+typedef intmax_t outcome_t[NOUTS];
+
+static const int out_0_x3_f = 0 ;
+static const int out_1_x3_f = 1 ;
+
+
+typedef struct hist_t {
+ outs_t *outcomes ;
+ count_t n_pos,n_neg ;
+} hist_t ;
+
+static hist_t *alloc_hist(void) {
+ hist_t *p = malloc_check(sizeof(*p)) ;
+ p->outcomes = NULL ;
+ p->n_pos = p->n_neg = 0 ;
+ return p ;
+}
+
+static void free_hist(hist_t *h) {
+ free_outs(h->outcomes) ;
+ free(h) ;
+}
+
+static void add_outcome(hist_t *h, count_t v, outcome_t o, int show) {
+ h->outcomes = add_outcome_outs(h->outcomes,o,NOUTS,v,show) ;
+}
+
+static void merge_hists(hist_t *h0, hist_t *h1) {
+ h0->n_pos += h1->n_pos ;
+ h0->n_neg += h1->n_neg ;
+ h0->outcomes = merge_outs(h0->outcomes,h1->outcomes,NOUTS) ;
+}
+
+static count_t sum_hist(hist_t *h) {
+ return sum_outs(h->outcomes) ;
+}
+
+
+static void do_dump_outcome(FILE *fhist, intmax_t *o, count_t c, int show) {
+ 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]);
+}
+
+static void just_dump_outcomes(FILE *fhist, hist_t *h) {
+ outcome_t buff ;
+ dump_outs(fhist,do_dump_outcome,h->outcomes,buff,NOUTS) ;
+}
+
+/*******************************************************/
+/* Context allocation, freeing and reinitialization */
+/*******************************************************/
+
+static void init(ctx_t *_a) {
+ int size_of_test = _a->_p->size_of_test;
+
+ _a->seed = rand();
+ _a->out_0_x3 = malloc_check(size_of_test*sizeof(*(_a->out_0_x3)));
+ _a->out_1_x3 = malloc_check(size_of_test*sizeof(*(_a->out_1_x3)));
+ _a->y = malloc_check(size_of_test*sizeof(*(_a->y)));
+ _a->x = malloc_check(size_of_test*sizeof(*(_a->x)));
+ _a->fst_barrier = pb_create(N);
+ _a->barrier = malloc_check(size_of_test*sizeof(*(_a->barrier)));
+}
+
+static void finalize(ctx_t *_a) {
+ free((void *)_a->y);
+ free((void *)_a->x);
+ free((void *)_a->out_0_x3);
+ free((void *)_a->out_1_x3);
+ pb_free(_a->fst_barrier);
+ free((void *)_a->barrier);
+}
+
+static void reinit(ctx_t *_a) {
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ _a->y[_i] = 0;
+ _a->x[_i] = 0;
+ _a->out_0_x3[_i] = -239487;
+ _a->out_1_x3[_i] = -239487;
+ _a->barrier[_i] = 0;
+ }
+}
+
+/**************************************/
+/* Prefetch (and check) global values */
+/**************************************/
+
+static void check_globals(ctx_t *_a) {
+ int *y = _a->y;
+ int *x = _a->x;
+ for (int _i = _a->_p->size_of_test-1 ; _i >= 0 ; _i--) {
+ if (rand_bit(&(_a->seed)) && y[_i] != 0) fatal("SAL, check_globals failed");
+ if (rand_bit(&(_a->seed)) && x[_i] != 0) fatal("SAL, check_globals failed");
+ }
+ pb_wait(_a->fst_barrier);
+}
+
+/***************/
+/* Litmus code */
+/***************/
+
+typedef struct {
+ int th_id; /* I am running on this thread */
+ int *cpu; /* On this cpu */
+ ctx_t *_a; /* In this context */
+} parg_t;
+
+
+
+
+
+static void *P0(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_0_x3 = _a->out_0_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P0\n"
+"#_litmus_P0_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P0_1\n\t"
+"str %w[x0],[%[x1]]\n"
+"#_litmus_P0_2\n\t"
+"dmb sy\n"
+"#_litmus_P0_3\n\t"
+"ldr %[x3],[%[x2]]\n"
+"#END _litmus_P0\n\t"
+:[x3] "=&r" (out_0_x3[_i]),[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+static void *P1(void *_vb) {
+ mbar();
+ parg_t *_b = (parg_t *)_vb;
+ ctx_t *_a = _b->_a;
+ int _ecpu = _b->cpu[_b->th_id];
+ force_one_affinity(_ecpu,AVAIL,_a->_p->verbose,"SAL");
+ check_globals(_a);
+ int _th_id = _b->th_id;
+ int volatile *barrier = _a->barrier;
+ int _size_of_test = _a->_p->size_of_test;
+ int _stride = _a->_p->stride;
+ int *out_1_x3 = _a->out_1_x3;
+ for (int _j = _stride ; _j > 0 ; _j--) {
+ for (int _i = _size_of_test-_j ; _i >= 0 ; _i -= _stride) {
+ barrier_wait(_th_id,_i,&barrier[_i]);
+ int trashed_x0;
+asm __volatile__ (
+"\n"
+"#START _litmus_P1\n"
+"#_litmus_P1_0\n\t"
+"mov %w[x0],#1\n"
+"#_litmus_P1_1\n\t"
+"str %w[x0],[%[x2]]\n"
+"#_litmus_P1_2\n\t"
+"dmb sy\n"
+"#_litmus_P1_3\n\t"
+"ldr %[x3],[%[x1]]\n"
+"#END _litmus_P1\n\t"
+:[x3] "=&r" (out_1_x3[_i]),[x0] "=&r" (trashed_x0)
+:[x1] "r" (&_a->x[_i]),[x2] "r" (&_a->y[_i])
+:"cc","memory"
+);
+ }
+ }
+ mbar();
+ return NULL;
+}
+
+typedef struct {
+ pm_t *p_mutex;
+ pb_t *p_barrier;
+ param_t *_p;
+ int z_id;
+ int *cpus;
+} zyva_t;
+
+#define NT N
+
+static void *zyva(void *_va) {
+ zyva_t *_a = (zyva_t *) _va;
+ param_t *_b = _a->_p;
+ pb_wait(_a->p_barrier);
+ pthread_t thread[NT];
+ parg_t parg[N];
+ f_t *fun[] = {&P0,&P1};
+ hist_t *hist = alloc_hist();
+ ctx_t ctx;
+ ctx._p = _b;
+
+ init(&ctx);
+ for (int _p = N-1 ; _p >= 0 ; _p--) {
+ parg[_p].th_id = _p; parg[_p]._a = &ctx;
+ parg[_p].cpu = &(_a->cpus[0]);
+ }
+
+ for (int n_run = 0 ; n_run < _b->max_run ; n_run++) {
+ if (_b->aff_mode == aff_random) {
+ pb_wait(_a->p_barrier);
+ if (_a->z_id == 0) perm_prefix_ints(&ctx.seed,_a->cpus,_b->ncpus_used,_b->ncpus);
+ pb_wait(_a->p_barrier);
+ } else {
+ }
+ if (_b->verbose>1) fprintf(stderr,"Run %i of %i\r", n_run, _b->max_run);
+ reinit(&ctx);
+ if (_b->do_change) perm_funs(&ctx.seed,fun,N);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ launch(&thread[_p],fun[_p],&parg[_p]);
+ }
+ if (_b->do_change) perm_threads(&ctx.seed,thread,NT);
+ for (int _p = NT-1 ; _p >= 0 ; _p--) {
+ join(&thread[_p]);
+ }
+ /* Log final states */
+ for (int _i = _b->size_of_test-1 ; _i >= 0 ; _i--) {
+ int _out_0_x3_i = ctx.out_0_x3[_i];
+ int _out_1_x3_i = ctx.out_1_x3[_i];
+ outcome_t o;
+ int cond;
+
+ cond = final_ok(final_cond(_out_0_x3_i,_out_1_x3_i));
+ o[out_0_x3_f] = _out_0_x3_i;
+ o[out_1_x3_f] = _out_1_x3_i;
+ add_outcome(hist,1,o,cond);
+ if (cond) { hist->n_pos++; } else { hist->n_neg++; }
+ }
+ }
+
+ finalize(&ctx);
+ return hist;
+}
+
+#define ENOUGH 10
+
+static int postlude(FILE *out,cmd_t *cmd,hist_t *hist,count_t p_true,count_t p_false,tsc_t total) {
+ fprintf(out,"Test SAL Forbidden\n");
+ fprintf(out,"Histogram (%i states)\n",finals_outs(hist->outcomes));
+ just_dump_outcomes(out,hist);
+ int cond = p_true == 0;
+ fprintf(out,"%s\n",cond?"Ok":"No");
+ fprintf(out,"\nWitnesses\n");
+ fprintf(out,"Positive: %" PCTR ", Negative: %" PCTR "\n",p_false,p_true);
+ fprintf(out,"Condition ~exists (0:X3=0 /\\ 1:X3=0) is %svalidated\n",cond ? "" : "NOT ");
+ fprintf(out,"Hash=8d89ac48ecfc60bb2f37937f74cbba0d\n");
+ count_t cond_true = p_true;
+ count_t cond_false = p_false;
+ fprintf(out,"Observation SAL %s %" PCTR " %" PCTR "\n",!cond_true ? "Never" : !cond_false ? "Always" : "Sometimes",cond_true,cond_false);
+ if (p_true > 0) {
+ }
+ fprintf(out,"Time SAL %.2f\n",total / 1000000.0);
+ fflush(out);
+ return cond;
+}
+
+static int run(cmd_t *cmd,cpus_t *def_all_cpus,FILE *out) {
+ tsc_t start = timeofday();
+ param_t prm ;
+/* Set some parameters */
+ prm.verbose = cmd->verbose;
+ prm.size_of_test = cmd->size_of_test;
+ prm.max_run = cmd->max_run;
+ prm.stride = cmd->stride;
+ prm.do_change = 1;
+ if (cmd->fix) prm.do_change = 0;
+/* Computes number of test concurrent instances */
+ int n_avail = cmd->avail > 0 ? cmd->avail : cmd->aff_cpus->sz;
+ if (n_avail > cmd->aff_cpus->sz) log_error("Warning: avail=%i, available=%i\n",n_avail, cmd->aff_cpus->sz);
+ int n_exe;
+ if (cmd->n_exe > 0) {
+ n_exe = cmd->n_exe;
+ } else {
+ n_exe = n_avail < N ? 1 : n_avail / N;
+ }
+/* Set affinity parameters */
+ cpus_t *all_cpus = cmd->aff_cpus;
+ int aff_cpus_sz = cmd->aff_mode == aff_random ? max(all_cpus->sz,N*n_exe) : N*n_exe;
+ int aff_cpus[aff_cpus_sz];
+ prm.aff_mode = cmd->aff_mode;
+ prm.ncpus = aff_cpus_sz;
+ prm.ncpus_used = N*n_exe;
+/* Show parameters to user */
+ if (prm.verbose) {
+ log_error( "SAL: n=%i, r=%i, s=%i",n_exe,prm.max_run,prm.size_of_test);
+ log_error(", st=%i",prm.stride);
+ if (cmd->aff_mode == aff_incr) {
+ log_error( ", i=%i",cmd->aff_incr);
+ } else if (cmd->aff_mode == aff_random) {
+ log_error(", +ra");
+ } else if (cmd->aff_mode == aff_custom) {
+ log_error(", +ca");
+ } else if (cmd->aff_mode == aff_scan) {
+ log_error(", +sa");
+ }
+ log_error(", p='");
+ cpus_dump(stderr,cmd->aff_cpus);
+ log_error("'");
+ log_error("\n");
+ }
+ if (cmd->aff_mode == aff_random) {
+ for (int k = 0 ; k < aff_cpus_sz ; k++) {
+ aff_cpus[k] = all_cpus->cpu[k % all_cpus->sz];
+ }
+ }
+ hist_t *hist = NULL;
+ int n_th = n_exe-1;
+ pthread_t th[n_th];
+ zyva_t zarg[n_exe];
+ pm_t *p_mutex = pm_create();
+ pb_t *p_barrier = pb_create(n_exe);
+ int next_cpu = 0;
+ int delta = cmd->aff_incr;
+ if (delta <= 0) {
+ for (int k=0 ; k < all_cpus->sz ; k++) all_cpus->cpu[k] = -1;
+ delta = 1;
+ } else {
+ delta %= all_cpus->sz;
+ }
+ int start_scan=0, max_start=gcd(delta,all_cpus->sz);
+ int *aff_p = aff_cpus;
+ for (int k=0 ; k < n_exe ; k++) {
+ zyva_t *p = &zarg[k];
+ p->_p = &prm;
+ p->p_mutex = p_mutex; p->p_barrier = p_barrier;
+ p->z_id = k;
+ p->cpus = aff_p;
+ if (cmd->aff_mode != aff_incr) {
+ aff_p += N;
+ } else {
+ for (int i=0 ; i < N ; i++) {
+ *aff_p = all_cpus->cpu[next_cpu]; aff_p++;
+ next_cpu += delta; next_cpu %= all_cpus->sz;
+ if (next_cpu == start_scan) {
+ start_scan++ ; start_scan %= max_start;
+ next_cpu = start_scan;
+ }
+ }
+ }
+ if (k < n_th) {
+ launch(&th[k],zyva,p);
+ } else {
+ hist = (hist_t *)zyva(p);
+ }
+ }
+
+ count_t n_outs = prm.size_of_test; n_outs *= prm.max_run;
+ for (int k=0 ; k < n_th ; k++) {
+ hist_t *hk = (hist_t *)join(&th[k]);
+ if (sum_hist(hk) != n_outs || hk->n_pos + hk->n_neg != n_outs) {
+ fatal("SAL, sum_hist");
+ }
+ merge_hists(hist,hk);
+ free_hist(hk);
+ }
+ cpus_free(all_cpus);
+ tsc_t total = timeofday() - start;
+ pm_free(p_mutex);
+ pb_free(p_barrier);
+
+ n_outs *= n_exe ;
+ if (sum_hist(hist) != n_outs || hist->n_pos + hist->n_neg != n_outs) {
+ fatal("SAL, sum_hist") ;
+ }
+ count_t p_true = hist->n_pos, p_false = hist->n_neg;
+ int cond = postlude(out,cmd,hist,p_true,p_false,total);
+ free_hist(hist);
+ return cond;
+}
+
+
+int main(int argc, char **argv) {
+ cpus_t *def_all_cpus = read_force_affinity(AVAIL,0);
+ if (def_all_cpus->sz < N) {
+ cpus_free(def_all_cpus);
+ return EXIT_SUCCESS;
+ }
+ 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};
+ cmd_t cmd = def;
+ parse_cmd(argc,argv,&def,&cmd);
+ int cond = run(&cmd,def_all_cpus,stdout);
+ if (def_all_cpus != cmd.aff_cpus) cpus_free(def_all_cpus);
+ return cond ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/tests/tcg/aarch64/litmus/Makefile b/tests/tcg/aarch64/litmus/Makefile
new file mode 100644
index 0000000..46178f2
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/Makefile
@@ -0,0 +1,53 @@
+GCC=aarch64-linux-gnu-gcc
+GCCOPTS=-D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -O2 -pthread -static
+LINKOPTS=
+SRC=\
+ ARMARM00.c\
+ ARMARM01.c\
+ ARMARM02.c\
+ ARMARM03.c\
+ ARMARM04+BIS.c\
+ ARMARM04.c\
+ ARMARM04+TER.c\
+ ARMARM05.c\
+ ARMARM06+AP+AA.c\
+ ARMARM06+AP+AP.c\
+ ARMARM06.c\
+ ARMARM07+SAL.c\
+
+EXE=$(SRC:.c=.exe)
+T=$(SRC:.c=.t)
+
+all: $(EXE) $(T)
+
+clean:
+ /bin/rm -f *.o *.s *.t *.exe *~
+
+cleansource:
+ /bin/rm -f *.o *.c *.h *.s *~
+
+affinity.o: affinity.c
+ $(GCC) $(GCCOPTS) -O2 -c affinity.c
+
+outs.o: outs.c
+ $(GCC) $(GCCOPTS) -O2 -c outs.c
+
+utils.o: utils.c
+ $(GCC) $(GCCOPTS) -O2 -c utils.c
+
+litmus_rand.o: litmus_rand.c
+ $(GCC) $(GCCOPTS) -O2 -c litmus_rand.c
+
+UTILS=affinity.o outs.o utils.o litmus_rand.o
+
+%.exe:%.s $(UTILS)
+ $(GCC) $(GCCOPTS) $(LINKOPTS) -o $@ $(UTILS) $<
+
+%.s:%.c
+ $(GCC) $(GCCOPTS) -S $<
+
+%.t:%.s
+ awk -f show.awk $< > $@
+
+tests: all
+ ./run.sh
diff --git a/tests/tcg/aarch64/litmus/README.txt b/tests/tcg/aarch64/litmus/README.txt
new file mode 100644
index 0000000..c160b8d
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/README.txt
@@ -0,0 +1,22 @@
+Tests produced by litmus for architecture AArch64 on linux
+
+COMPILING
+ with command 'make [-j N]' or 'sh comp.sh'
+
+RUNNING ALL TESTS
+ with command 'sh run.sh'. Test result on standard output.
+
+RUNNING ONE TEST
+ Tests are .exe files, for instance ARMARM06.exe, run it by './ARMARM06.exe'
+
+RUNNING OPTIONS
+ Main options to the run.sh script and to .exe files:
+ -v be verbose (can be repeated).
+ -a <n> number of (logical) processors available, default 0.
+ The default value of 0 means that .exe files attempt
+ to infer the actual number of logical threads.
+ -s <n> one run operates on arrays of size <n>, default 100000.
+ -r <n> number of runs, default 10.
+
+ For more options see for instance './ARMARM06.exe -help' and litmus documentation
+ <http://diy.inria.fr/doc/litmus.html>
diff --git a/tests/tcg/aarch64/litmus/affinity.c b/tests/tcg/aarch64/litmus/affinity.c
new file mode 100644
index 0000000..9535bf2
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/affinity.c
@@ -0,0 +1,159 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdio.h>
+#include <sched.h>
+#include <unistd.h>
+#include "utils.h"
+#include "affinity.h"
+
+#ifdef CPUS_DEFINED
+cpus_t *read_affinity(void) {
+ cpu_set_t mask;
+ int sz = 0 ;
+ int res = pthread_getaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+
+ if (res != 0) {
+ errexit("pthread_getaffinity_np",res);
+ }
+ for (int p=0 ; p < CPU_SETSIZE ; p++) {
+ if (CPU_ISSET(p,&mask)) sz++ ;
+ }
+
+ cpus_t *r = cpus_create(sz) ;
+ for (int p=0, *q=r->cpu ; p < CPU_SETSIZE ; p++) {
+ if (CPU_ISSET(p,&mask)) *q++ = p ;
+ }
+ return r ;
+}
+
+#endif
+/* Attempt to force processors wake up, on devices where unused procs
+ go to sleep... */
+
+
+#ifdef FORCE_AFFINITY
+const static tsc_t sec = (tsc_t)1000000 ;
+
+static void* loop(void *p) {
+ tsc_t *q = p ;
+ tsc_t max = *q ;
+ while (timeofday() < max) ;
+ return NULL ;
+}
+
+
+static void warm_up(int sz, tsc_t d) {
+ pthread_t th[sz];
+ d += timeofday() ;
+ for (int k = 0 ; k < sz ; k++) launch(&th[k], loop, &d) ;
+ for (int k = 0 ; k < sz ; k++) join(&th[k]) ;
+}
+
+#ifdef CPUS_DEFINED
+cpus_t *read_force_affinity(int n_avail, int verbose) {
+ int sz = n_avail <= 1 ? 1 : n_avail ;
+ tsc_t max = sec / 100 ;
+
+ for ( ; ; ) {
+ warm_up(sz+1,max) ;
+ cpus_t *r = read_affinity() ;
+ if (n_avail <= r->sz) return r ;
+ if (verbose) {
+ fprintf(stderr,"Read affinity: '") ;
+ cpus_dump(stderr,r) ;
+ fprintf(stderr,"'\n") ;
+ }
+ cpus_free(r) ;
+ }
+}
+#endif
+#endif
+
+#ifdef CPUS_DEFINED
+
+/* Enforcing processor affinity.
+ Notice that logical processor numbers may be negative.
+ In that case, affinity setting is ignored */
+
+
+void write_affinity(cpus_t *p) {
+ cpu_set_t mask;
+ int exists_pos = 0 ;
+
+ CPU_ZERO(&mask) ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ if (p->cpu[k] >= 0) {
+ CPU_SET(p->cpu[k],&mask) ;
+ exists_pos = 1 ;
+ }
+ }
+ if (exists_pos) {
+ int r = pthread_setaffinity_np(pthread_self(),sizeof(mask),&mask) ;
+ if (r != 0) {
+ errexit("pthread_setaffinity_np",r) ;
+ }
+ }
+}
+#endif
+
+void write_one_affinity(int a) {
+ if (a >= 0) {
+ cpu_set_t mask;
+ CPU_ZERO(&mask) ;
+ CPU_SET(a,&mask) ;
+ int r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+ if (r != 0) {
+ errexit("pthread_setaffinity_np",r) ;
+ }
+ }
+}
+
+#ifdef FORCE_AFFINITY
+/* Get the number of present cpus, fragile */
+
+static const char *present = "/sys/devices/system/cpu/present" ;
+
+static int get_present(void) {
+ FILE *fp = fopen(present,"r") ;
+ if (fp == NULL) return -1 ;
+ int r1,r2 ;
+ int n = fscanf(fp,"%d-%d\n",&r1,&r2) ;
+ fclose(fp) ;
+ if (n != 2) return -1 ;
+ return r2-r1+1 ;
+}
+
+void force_one_affinity(int a, int sz,int verbose, char *name) {
+ if (a >= 0) {
+ cpu_set_t mask;
+ int r ;
+ CPU_ZERO(&mask) ;
+ CPU_SET(a,&mask) ;
+ do {
+ r = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) ;
+ if (r != 0) {
+ if (verbose)
+ fprintf(stderr,"%s: force %i failed\n",name,a) ;
+ int nwarm = get_present() ;
+ if (verbose > 1)
+ fprintf(stderr,"%s: present=%i\n",name,nwarm) ;
+ if (nwarm < 0) nwarm = sz+1 ;
+ warm_up(nwarm,sec/100) ;
+ }
+ } while (r != 0) ;
+ }
+}
+#endif
diff --git a/tests/tcg/aarch64/litmus/affinity.h b/tests/tcg/aarch64/litmus/affinity.h
new file mode 100644
index 0000000..9fb6a25
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/affinity.h
@@ -0,0 +1,34 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _AFFINITY_H
+#define _AFFINITY_H 1
+
+#include "utils.h"
+
+#ifdef CPUS_DEFINED
+cpus_t *read_affinity(void) ;
+#ifdef FORCE_AFFINITY
+cpus_t *read_force_affinity(int n_avail, int verbose) ;
+#endif
+void write_affinity(cpus_t *p) ;
+#endif
+
+void write_one_affinity(int cpu) ;
+#ifdef FORCE_AFFINITY
+void force_one_affinity(int cpu, int sz, int verbose, char *name) ;
+#endif
+
+#endif
diff --git a/tests/tcg/aarch64/litmus/comp.sh b/tests/tcg/aarch64/litmus/comp.sh
new file mode 100644
index 0000000..62d65ba
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/comp.sh
@@ -0,0 +1,30 @@
+GCC=gcc
+GCCOPTS="-D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -O2 -pthread"
+LINKOPTS=""
+/bin/rm -f *.exe *.s
+$GCC $GCCOPTS -O2 -c affinity.c
+$GCC $GCCOPTS -O2 -c outs.c
+$GCC $GCCOPTS -O2 -c utils.c
+$GCC $GCCOPTS -O2 -c litmus_rand.c
+$GCC $GCCOPTS $LINKOPTS -o ARMARM00.exe affinity.o outs.o utils.o litmus_rand.o ARMARM00.c
+$GCC $GCCOPTS -S ARMARM00.c && awk -f show.awk ARMARM00.s > ARMARM00.t && /bin/rm ARMARM00.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM01.exe affinity.o outs.o utils.o litmus_rand.o ARMARM01.c
+$GCC $GCCOPTS -S ARMARM01.c && awk -f show.awk ARMARM01.s > ARMARM01.t && /bin/rm ARMARM01.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM02.exe affinity.o outs.o utils.o litmus_rand.o ARMARM02.c
+$GCC $GCCOPTS -S ARMARM02.c && awk -f show.awk ARMARM02.s > ARMARM02.t && /bin/rm ARMARM02.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM03.exe affinity.o outs.o utils.o litmus_rand.o ARMARM03.c
+$GCC $GCCOPTS -S ARMARM03.c && awk -f show.awk ARMARM03.s > ARMARM03.t && /bin/rm ARMARM03.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04+BIS.exe affinity.o outs.o utils.o litmus_rand.o ARMARM04+BIS.c
+$GCC $GCCOPTS -S ARMARM04+BIS.c && awk -f show.awk ARMARM04+BIS.s > ARMARM04+BIS.t && /bin/rm ARMARM04+BIS.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04.exe affinity.o outs.o utils.o litmus_rand.o ARMARM04.c
+$GCC $GCCOPTS -S ARMARM04.c && awk -f show.awk ARMARM04.s > ARMARM04.t && /bin/rm ARMARM04.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM04+TER.exe affinity.o outs.o utils.o litmus_rand.o ARMARM04+TER.c
+$GCC $GCCOPTS -S ARMARM04+TER.c && awk -f show.awk ARMARM04+TER.s > ARMARM04+TER.t && /bin/rm ARMARM04+TER.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM05.exe affinity.o outs.o utils.o litmus_rand.o ARMARM05.c
+$GCC $GCCOPTS -S ARMARM05.c && awk -f show.awk ARMARM05.s > ARMARM05.t && /bin/rm ARMARM05.s
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06+AP+AA.exe affinity.o outs.o utils.o litmus_rand.o ARMARM06+AP+AA.c
+$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
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06+AP+AP.exe affinity.o outs.o utils.o litmus_rand.o ARMARM06+AP+AP.c
+$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
+$GCC $GCCOPTS $LINKOPTS -o ARMARM06.exe affinity.o outs.o utils.o litmus_rand.o ARMARM06.c
+$GCC $GCCOPTS -S ARMARM06.c && awk -f show.awk ARMARM06.s > ARMARM06.t && /bin/rm ARMARM06.s
diff --git a/tests/tcg/aarch64/litmus/litmus_rand.c b/tests/tcg/aarch64/litmus/litmus_rand.c
new file mode 100644
index 0000000..de33032
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/litmus_rand.c
@@ -0,0 +1,64 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdint.h>
+#include "litmus_rand.h"
+
+/*
+ Simple generator
+ http://en.wikipedia.org/wiki/Linear_congruential_generator
+*/
+
+
+/*
+
+ From ocaml sources: (globroot.c)
+ Linear congruence with modulus = 2^32, multiplier = 69069
+ (Knuth vol 2 p. 106, line 15 of table 1), additive = 25173.
+
+
+ Knuth (vol 2 p. 13) shows that the least significant bits are
+ "less random" than the most significant bits with a modulus of 2^m.
+ We just swap half words, enough? */
+
+static const uint32_t a = 69069;
+static const uint32_t c = 25173 ;
+
+inline static uint32_t unlocked_rand(st_t *st) {
+ uint32_t r = a * *st + c ;
+ *st = r ;
+ /* Swap high & low bits */
+ uint32_t low = r & 0xffff ;
+ uint32_t high = r >> 16 ;
+ r = high | (low << 16) ;
+ return r ;
+}
+
+int rand_bit(st_t *st) {
+ uint32_t r = unlocked_rand(st) ;
+ r &= 1 ;
+ return r ;
+}
+
+static const uint32_t r_max = UINT32_MAX ;
+
+uint32_t rand_k (uint32_t *st,uint32_t k) {
+ uint32_t r, v ;
+ do {
+ r = unlocked_rand(st) ;
+ v = r % k ;
+ } while (r-v > r_max-k+1) ;
+ return v ;
+}
diff --git a/tests/tcg/aarch64/litmus/litmus_rand.h b/tests/tcg/aarch64/litmus/litmus_rand.h
new file mode 100644
index 0000000..c358ccb
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/litmus_rand.h
@@ -0,0 +1,29 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _LITMUS_RAND_H
+#define _LITMUS_RAND_H 1
+
+#include <stdint.h>
+
+/* type of state for pseudorandom generators */
+typedef uint32_t st_t ;
+
+/* Unlocked random bit */
+
+int rand_bit(st_t *st) ;
+uint32_t rand_k(st_t *st,uint32_t n) ;
+
+#endif
diff --git a/tests/tcg/aarch64/litmus/outs.c b/tests/tcg/aarch64/litmus/outs.c
new file mode 100644
index 0000000..178f1d2
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/outs.c
@@ -0,0 +1,148 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include "outs.h"
+
+/**********************/
+/* Lexicographic tree */
+/**********************/
+
+#if 0
+static void debug(int *t, int i, int j) {
+ for (int k=i ; k <= j ; k++)
+ fprintf(stderr,"%i",t[k]) ;
+ fprintf(stderr,"\n") ;
+}
+#endif
+
+
+void *malloc_check(size_t sz) ;
+
+static outs_t *alloc_outs(intmax_t k) {
+ outs_t *r = malloc_check(sizeof(*r)) ;
+ r->k = k ;
+ r->c = 0 ;
+ r->show = 0 ;
+ r->next = r->down = NULL ;
+ return r ;
+}
+
+void free_outs(outs_t *p) {
+ if (p == NULL) return ;
+ free_outs(p->next) ;
+ free_outs(p->down) ;
+ free(p) ;
+}
+
+/* Worth writing as a loop, since called many times */
+static outs_t *loop_add_outcome_outs(outs_t *p, intmax_t *k, int i, count_t c, int show) {
+ outs_t *r = p ;
+ if (p == NULL || k[i] < p->k) {
+ r = alloc_outs(k[i]) ;
+ r->next = p ;
+ p = r ;
+ }
+ for ( ; ; ) {
+ outs_t **q ;
+ if (k[i] > p->k) {
+ q = &(p->next) ;
+ p = p->next ;
+ } else if (i <= 0) {
+ p->c += c ;
+ p->show = show || p->show ;
+ return r ;
+ } else {
+ i-- ;
+ q = &(p->down) ;
+ p = p->down ;
+ }
+ if (p == NULL || k[i] < p->k) {
+ outs_t *a = alloc_outs(k[i]) ;
+ a->next = p ;
+ p = a ;
+ *q = a ;
+ }
+ }
+}
+
+outs_t *add_outcome_outs(outs_t *p, intmax_t *k, int sz, count_t c, int show) {
+ return loop_add_outcome_outs(p,k,sz-1,c,show) ;
+}
+
+count_t sum_outs(outs_t *p) {
+ count_t r = 0 ;
+ for ( ; p ; p = p->next) {
+ r += p->c ;
+ r += sum_outs(p->down) ;
+ }
+ return r ;
+}
+
+int finals_outs(outs_t *p) {
+ int r = 0 ;
+ for ( ; p ; p = p->next) {
+ if (p->c > 0) r++ ;
+ r += finals_outs(p->down) ;
+ }
+ return r ;
+}
+
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff,int sz) {
+ for ( ; p ; p = p->next) {
+ buff[sz-1] = p->k ;
+ if (p->c > 0) {
+ dout(chan,buff,p->c,p->show) ;
+ } else if (p->down) {
+ dump_outs(chan,dout,p->down,buff,sz-1) ;
+ }
+ }
+}
+
+/* merge p and q into p */
+static outs_t *do_merge_outs(outs_t *p, outs_t *q) {
+ if (q == NULL) { // Nothing to add
+ return p ;
+ }
+ if (p == NULL || q->k < p->k) { // Need a cell
+ outs_t *r = alloc_outs(q->k) ;
+ r->next = p ;
+ p = r ;
+ }
+ if (p->k == q->k) {
+ p->c += q->c ;
+ p->show = p->show || q->show ;
+ p->down = do_merge_outs(p->down,q->down) ;
+ p->next = do_merge_outs(p->next,q->next) ;
+ } else {
+ p->next = do_merge_outs(p->next,q) ;
+ }
+ return p ;
+}
+
+outs_t *merge_outs(outs_t *p, outs_t *q, int sz) {
+ return do_merge_outs(p,q) ;
+}
+
+int same_outs(outs_t *p,outs_t *q) {
+ while (p && q) {
+ if (p->k != q->k || p->c != q->c || p->show != q->show) return 0 ;
+ if (!same_outs(p->down,q->down)) return 0 ;
+ p = p->next ;
+ q = q->next ;
+ }
+ return p == q ; /* == NULL */
+}
diff --git a/tests/tcg/aarch64/litmus/outs.h b/tests/tcg/aarch64/litmus/outs.h
new file mode 100644
index 0000000..761590f
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/outs.h
@@ -0,0 +1,49 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _OUTS_H
+#define _OUTS_H 1
+
+#include <stdio.h>
+
+/************************/
+/* Histogram structure */
+/************************/
+
+
+/* 64bit counters, should be enough! */
+#include <inttypes.h>
+typedef uint64_t count_t;
+#define PCTR PRIu64
+
+
+
+
+typedef struct outs_t {
+ struct outs_t *next,*down ;
+ count_t c ;
+ intmax_t k ;
+ int show ;
+} outs_t ;
+
+void free_outs(outs_t *p) ;
+outs_t *add_outcome_outs(outs_t *p, intmax_t *o, int sz, count_t v, int show) ;
+int finals_outs(outs_t *p) ;
+count_t sum_outs(outs_t *p) ;
+typedef void dump_outcome(FILE *chan, intmax_t *o, count_t c, int show) ;
+void dump_outs (FILE *chan, dump_outcome *dout,outs_t *p, intmax_t *buff, int sz) ;
+outs_t *merge_outs(outs_t *p,outs_t *q, int sz) ;
+int same_outs(outs_t *p,outs_t *q) ;
+#endif
diff --git a/tests/tcg/aarch64/litmus/run.sh b/tests/tcg/aarch64/litmus/run.sh
new file mode 100755
index 0000000..21604a1
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/run.sh
@@ -0,0 +1,378 @@
+date
+LITMUSOPTS="${@:-$LITMUSOPTS}"
+SLEEP=0
+if [ ! -f ARMARM00.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM00.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM00
+"PodWWPL RfeLA PodRRAP Fre"
+
+{0:X1=x; 0:X3=y; 1:X1=y; 1:X3=x; 1:X2=-1;}
+
+ P0 | P1 ;
+ MOV W0,#1 | LDAR W0,[X1] ;
+ STR W0,[X1] | CMP W0,#1 ;
+ MOV W2,#1 | B.NE Exit1 ;
+ STLR W2,[X3] | LDR W2,[X3] ;
+ | Exit1: ;
+
+~exists (1:X0=1 /\ 1:X2=0)
+Generated assembler
+EOF
+cat ARMARM00.t
+$QEMU ./ARMARM00.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM01.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM01.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM01
+"PodWWPL RfeLP DpAddrdR Fre"
+
+{0:X1=x; 0:X3=y; 1:X1=y; 1:X4=x; 1:X3=-1;}
+
+ P0 | P1 ;
+ MOV W0,#1 | LDR W0,[X1] ;
+ STR W0,[X1] | CMP W0,#1 ;
+ MOV W2,#1 | B.NE Exit1 ;
+ STLR W2,[X3] | EOR W2,W0,W0 ;
+ | LDR W3,[X4,W2,SXTW] ;
+ | Exit1: ;
+
+~exists (1:X0=1 /\ 1:X3=0)
+Generated assembler
+EOF
+cat ARMARM01.t
+$QEMU ./ARMARM01.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM02.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM02.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM02
+
+{0:X1=x; 0:X3=y; 1:X1=y; 1:X4=x; 1:X3=-1; 2:X1=y; 2:X4=x; 2:X3=-1;}
+
+ P0 | P1 | P2 ;
+ MOV W0,#1 | LDR W0,[X1] | LDR W0,[X1] ;
+ STR W0,[X1] | CMP W0,#1 | CMP W0,#1 ;
+ MOV W2,#1 | B.NE Exit1 | B.NE Exit2 ;
+ STLR W2,[X3] | EOR W2,W0,W0 | EOR W2,W0,W0 ;
+ | LDR W3,[X4,W2,SXTW] | LDR W3,[X4,W2,SXTW] ;
+ | Exit1: | Exit2: ;
+
+~exists (1:X0=1 /\ 1:X3=0 \/ 2:X0=1 /\ 2:X3=0)
+Generated assembler
+EOF
+cat ARMARM02.t
+$QEMU ./ARMARM02.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM03.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM03.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM03
+"PodWWPL RfeLP DpAddrdR Fre"
+
+{y=z; z=-1; 0:X1=x; 0:X3=y; 1:X3=y; 1:X9=-1;}
+
+ P0 | P1 ;
+ MOV W0,#1 | LDR X0,[X3] ;
+ STR W0,[X1] | LDR W9,[X0] ;
+ STLR X1,[X3] | ;
+
+~exists (1:X0=x /\ 1:X9=0)
+Generated assembler
+EOF
+cat ARMARM03.t
+$QEMU ./ARMARM03.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM04+BIS.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM04+BIS.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM04+BIS
+"RfeLA PodRWAP Rfe DpAddrdRPA FreAL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 2:X4=x; 2:X3=-1;}
+
+ P0 | P1 | P2 ;
+ MOV W0,#1 | LDAR W0,[X1] | LDR W0,[X1] ;
+ STLR W0,[X1] | CMP W0,#1 | CMP W0,#1 ;
+ | B.NE Exit1 | B.NE Exit2 ;
+ | MOV W2,#1 | EOR W2,W0,W0 ;
+ | STR W2,[X3] | ADD X5,X4,W2,SXTW ;
+ | Exit1: | LDR W3,[X5] ;
+ | | Exit2: ;
+
+exists (1:X0=1 /\ 2:X0=1 /\ 2:X3=0)
+Generated assembler
+EOF
+cat ARMARM04+BIS.t
+$QEMU ./ARMARM04+BIS.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM04.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM04.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM04
+"RfeLA PodRWAP Rfe DpAddrdRPA FreAL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 2:X4=x; 2:X3=-1;}
+
+ P0 | P1 | P2 ;
+ MOV W0,#1 | LDAR W0,[X1] | LDR W0,[X1] ;
+ STLR W0,[X1] | CMP W0,#1 | CMP W0,#1 ;
+ | B.NE Exit1 | B.NE Exit2 ;
+ | MOV W2,#1 | EOR W2,W0,W0 ;
+ | STR W2,[X3] | ADD X5,X4,W2,SXTW ;
+ | Exit1: | LDAR W3,[X5] ;
+ | | Exit2: ;
+
+~exists (1:X0=1 /\ 2:X0=1 /\ 2:X3=0)
+Generated assembler
+EOF
+cat ARMARM04.t
+$QEMU ./ARMARM04.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM04+TER.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM04+TER.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM04+TER
+"RfeLA PodRWAP Rfe PodRRPA FreAL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 2:X3=x;}
+
+ P0 | P1 | P2 ;
+ MOV W0,#1 | LDAR W0,[X1] | LDR W0,[X1] ;
+ STLR W0,[X1] | MOV W2,#1 | LDAR W2,[X3] ;
+ | STR W2,[X3] | ;
+
+exists (1:X0=1 /\ 2:X0=1 /\ 2:X2=0)
+Generated assembler
+EOF
+cat ARMARM04+TER.t
+$QEMU ./ARMARM04+TER.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM05.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM05.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM05
+"Rfe PodRWPL RfeLP DpAddrdR Fre"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 2:X4=x; 2:X3=-1;}
+
+ P0 | P1 | P2 ;
+ MOV W0,#1 | LDR W0,[X1] | LDR W0,[X1] ;
+ STR W0,[X1] | CMP W0,#1 | CMP W0,#1 ;
+ | B.NE Exit1 | B.NE Exit2 ;
+ | MOV W2,#1 | EOR W2,W0,W0 ;
+ | STLR W2,[X3] | LDR W3,[X4,W2,SXTW] ;
+ | Exit1: | Exit2: ;
+
+~exists (1:X0=1 /\ 2:X0=1 /\ 2:X3=0)
+Generated assembler
+EOF
+cat ARMARM05.t
+$QEMU ./ARMARM05.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM06+AP+AA.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM06+AP+AA.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM06+AP+AA
+"RfeLA PodRRAP FrePL RfeLA PodRRAA FreAL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 3:X1=y; 3:X3=x;}
+
+ P0 | P1 | P2 | P3 ;
+ MOV W0,#1 | LDAR W0,[X1] | MOV W0,#1 | LDAR W0,[X1] ;
+ STLR W0,[X1] | LDR W2,[X3] | STLR W0,[X1] | LDAR W2,[X3] ;
+
+exists (1:X0=1 /\ 1:X2=0 /\ 3:X0=1 /\ 3:X2=0)
+Generated assembler
+EOF
+cat ARMARM06+AP+AA.t
+$QEMU ./ARMARM06+AP+AA.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM06+AP+AP.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM06+AP+AP.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM06+AP+AP
+"RfeLA PodRRAP FrePL RfeLA PodRRAP FrePL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 3:X1=y; 3:X3=x;}
+
+ P0 | P1 | P2 | P3 ;
+ MOV W0,#1 | LDAR W0,[X1] | MOV W0,#1 | LDAR W0,[X1] ;
+ STLR W0,[X1] | LDR W2,[X3] | STLR W0,[X1] | LDR W2,[X3] ;
+
+exists (1:X0=1 /\ 1:X2=0 /\ 3:X0=1 /\ 3:X2=0)
+Generated assembler
+EOF
+cat ARMARM06+AP+AP.t
+$QEMU ./ARMARM06+AP+AP.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM06.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM06.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 ARMARM06
+"RfeLA PodRRAA FreAL RfeLA PodRRAA FreAL"
+
+{0:X1=x; 1:X1=x; 1:X3=y; 2:X1=y; 3:X1=y; 3:X3=x;}
+
+ P0 | P1 | P2 | P3 ;
+ MOV W0,#1 | LDAR W0,[X1] | MOV W0,#1 | LDAR W0,[X1] ;
+ STLR W0,[X1] | LDAR W2,[X3] | STLR W0,[X1] | LDAR W2,[X3] ;
+
+~exists (1:X0=1 /\ 1:X2=0 /\ 3:X0=1 /\ 3:X2=0)
+Generated assembler
+EOF
+cat ARMARM06.t
+$QEMU ./ARMARM06.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+if [ ! -f ARMARM07+SAL.no ]; then
+cat <<'EOF'
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Results for aarch64.tests/HAND/ARMARM07+SAL.litmus %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+AArch64 SAL
+
+{0:X1=x; 0:X2=y; 1:X1=x; 1:X2=y;}
+
+ P0 | P1 ;
+ MOV W0,#1 | MOV W0,#1 ;
+ STR W0,[X1] | STR W0,[X2] ;
+ DMB SY | DMB SY ;
+ LDR X3,[X2] | LDR X3,[X1] ;
+
+~exists (0:X3=0 /\ 1:X3=0)
+Generated assembler
+EOF
+cat ARMARM07+SAL.t
+$QEMU ./ARMARM07+SAL.exe -q $LITMUSOPTS
+ret=$?
+if [ $ret -eq 1 ]; then
+ echo "FAILED";
+ exit 1;
+fi
+fi
+sleep $SLEEP
+
+cat <<'EOF'
+Revision exported, version 7.22
+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
+Parameters
+#define SIZE_OF_TEST 100000
+#define NUMBER_OF_RUN 10
+#define AVAIL 0
+#define STRIDE 1
+#define MAX_LOOP 0
+/* gcc options: -D_GNU_SOURCE -DFORCE_AFFINITY -Wall -std=gnu99 -O2 -pthread */
+/* barrier: user */
+/* launch: changing */
+/* affinity: incr0 */
+/* alloc: dynamic */
+/* memory: direct */
+/* stride: 1 */
+/* safer: write */
+/* preload: random */
+/* speedcheck: no */
+/* proc used: 0 */
+EOF
+head -1 comp.sh
+echo "LITMUSOPTS=$LITMUSOPTS"
+date
diff --git a/tests/tcg/aarch64/litmus/show.awk b/tests/tcg/aarch64/litmus/show.awk
new file mode 100644
index 0000000..c8ecf20
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/show.awk
@@ -0,0 +1,2 @@
+/START _litmus_P/ { print $0 }
+/_litmus_P[0-9]+_[0-9]+/ { getline; print $0 ; }
diff --git a/tests/tcg/aarch64/litmus/utils.c b/tests/tcg/aarch64/litmus/utils.c
new file mode 100644
index 0000000..cc989b0
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/utils.c
@@ -0,0 +1,1148 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include "utils.h"
+
+/********/
+/* Misc */
+/********/
+
+FILE *errlog ;
+
+static void checkerrlog(void) {
+ if (!errlog) errlog = stderr ;
+}
+
+void seterrlog(FILE *chan) {
+ errlog = chan ;
+}
+
+int log_error(const char *fmt, ...) {
+ int result;
+ va_list args;
+ va_start(args, fmt);
+ checkerrlog() ;
+ result = vfprintf(errlog, fmt, args);
+ fflush(errlog);
+ va_end(args);
+ return result;
+}
+
+void fatal(char *msg) {
+ log_error("Failure: %s\n", msg) ;
+ fclose(errlog);
+ fprintf(stdout,"Failure: %s\n", msg) ;
+ exit(1) ;
+}
+
+void errexit(char *msg,int err) {
+ log_error("%s: %s\n",msg,strerror(err)) ;
+ fclose(errlog);
+ exit(2) ;
+}
+
+void *malloc_check(size_t sz) {
+ if (sz == 0) return NULL ;
+ void *p = malloc(sz) ;
+ if (!p) {
+ if (!errno) errno = ENOMEM ;
+ errexit("malloc",errno) ;
+ }
+ return p ;
+}
+
+int max(int n, int m) { return n < m ? m : n ; }
+
+void pp_ints(FILE *fp,int *p,int n) {
+ if (n > 0) {
+ fprintf(fp,"%i",p[0]) ;
+ for (int k = 1 ; k < n ; k++) {
+ fprintf(fp,",%i",p[k]) ;
+ }
+ }
+}
+
+
+void *do_align(void *p,size_t sz) {
+ uintptr_t x = (uintptr_t)p ;
+ x += sz-1 ;
+ x /= sz ;
+ x *= sz ;
+ return (void *)x ;
+}
+
+void *do_noalign(void *p,size_t sz) {
+ void *q = do_align(p,sz) ;
+ void *r = q - sz/2 ;
+ if (r < p) r = q + sz/2 ;
+ return r ;
+}
+
+void cat_file(char *path, char *msg, FILE *out) {
+ FILE *fp = fopen(path,"r") ;
+ if (fp == NULL) return ;
+ fprintf(out,"%s\n",msg) ;
+ int c,nl=1 ;
+ while ((c = fgetc(fp)) != EOF) {
+ fputc(c,out) ;
+ nl = c == '\n' ;
+ }
+ fclose(fp) ;
+ if (!nl) fputc('\n',out) ;
+}
+
+/************/
+/* CPU sets */
+/************/
+
+cpus_t *cpus_create(int sz) {
+ cpus_t *r = malloc_check(sizeof(*r)) ;
+ r->sz = sz ;
+ r->cpu = malloc_check(sizeof(r->cpu[0])*sz) ;
+ return r ;
+}
+
+cpus_t *cpus_create_init(int sz, int t[]) {
+ cpus_t *r = cpus_create(sz) ;
+ for (int k = 0 ; k < sz ; k++) r->cpu[k] = t[k] ;
+ return r ;
+}
+
+void cpus_free(cpus_t *p) {
+ free(p->cpu) ;
+ free(p) ;
+}
+
+void cpus_dump(FILE *fp, cpus_t *p) {
+ pp_ints(fp,p->cpu,p->sz) ;
+}
+
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) {
+ for (int k = 0 ; k < sz ; k += nprocs) {
+ fprintf(fp,"[") ;
+ pp_ints(fp,&p[k],nprocs) ;
+ fprintf(fp,"] {") ;
+ if (nprocs > 0) {
+ fprintf(fp,"%i",cm->cpu[p[k]]) ;
+ for (int i = 1 ; i < nprocs ; i++) {
+ fprintf(fp,",%i",cm->cpu[p[k+i]]) ;
+ }
+ }
+ fprintf(fp,"}\n") ;
+ }
+}
+
+/*************/
+/* Int array */
+/*************/
+
+
+void ints_dump(FILE *fp, ints_t *p) {
+ if (p->sz > 0) {
+ fprintf(fp,"%i:%i",0,p->t[0]) ;
+ for (int k = 1 ; k < p->sz ; k++) {
+ fprintf(fp,",%i:%i",k,p->t[k]) ;
+ }
+ }
+}
+
+/***********************/
+/* Prefetch directives */
+/***********************/
+void prefetch_dump(FILE *fp, prfdirs_t *p) {
+ prfproc_t *q = p->t ;
+ int some = 0 ;
+ for (int _p = 0 ; _p < p->nthreads ; _p++) {
+ int nvars = q[_p].nvars ;
+ prfone_t *r = q[_p].t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ prfdir_t dir = r[_v].dir ;
+ if (dir != none) {
+ char c = 'I' ;
+ if (dir == flush) c = 'F' ;
+ else if (dir == touch) c = 'T' ;
+ else if (dir == touch_store) c = 'W' ;
+ if (some) {
+ fprintf(fp,",") ;
+ } else {
+ some = 1 ;
+ }
+ fprintf(fp,"%i:%s=%c",_p,r[_v].name,c) ;
+ }
+ }
+ }
+}
+
+static void set_prefetch(prfdirs_t *p, prfdir_t d) {
+ prfproc_t *q = p->t ;
+ for (int _p = 0 ; _p < p->nthreads ; _p++) {
+ int nvars = q[_p].nvars ;
+ prfone_t *r = q[_p].t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ r[_v].dir = d ;
+ }
+ }
+}
+
+/* ??? */
+
+int gcd(int a, int b) {
+ for ( ; ; ) {
+ if (a == 0) return b ;
+ int tmp = a ;
+ a = b % a ;
+ b = tmp ;
+ }
+}
+
+/* SMT description */
+
+
+cpus_t *coremap_seq(int navail, int nways) {
+ cpus_t *r = cpus_create(navail) ;
+ int ncores = navail / nways ;
+ int i = 0 ;
+ for (int c = 0 ; c < ncores ; c++) {
+ for (int k = 0 ; k < nways ; k++) {
+ r->cpu[i++] = c ;
+ }
+ }
+ return r ;
+}
+
+cpus_t *coremap_end(int navail, int nways) {
+ cpus_t *r = cpus_create(navail) ;
+ int ncores = navail / nways ;
+ int i = 0 ;
+ for (int k = 0 ; k < nways ; k++) {
+ for (int c = 0 ; c < ncores ; c++) {
+ r->cpu[i++] = c ;
+ }
+ }
+ return r ;
+}
+
+typedef struct {
+ int ncores ;
+ cpus_t **core ;
+} mapcore_t ;
+
+
+static void mapcore_free(mapcore_t *p) {
+ for (int c = 0 ; c < p->ncores ; c++) cpus_free(p->core[c]) ;
+ free(p->core) ;
+ free(p) ;
+}
+
+#if 0
+static mapcore_t *inverse_coremap(cpus_t *p, int nways) {
+ mapcore_t *r = malloc_check(sizeof(*r)) ;
+ r->ncores = p->sz / nways ;
+ r->core = malloc_check(r->ncores * sizeof(r->core[0])) ;
+ for (int k = 0 ; k < r->ncores ; k++) {
+ r->core[k] = cpus_create(nways) ;
+ r->core[k]->sz = 0 ;
+ }
+ for (int k = 0 ; k < p->sz ; k++) {
+ int c = p->cpu[k] ;
+ cpus_t *q = r->core[c] ;
+ q->cpu[q->sz++] = k ;
+ }
+ return r ;
+}
+#endif
+
+static int get_ncores(cpus_t *cm) {
+ int r = 0;
+ for (int k = 0 ; k < cm->sz ; k++) {
+ if (cm->cpu[k] > r) r = cm->cpu[k] ;
+ }
+ return r+1 ;
+}
+
+cpus_t *get_core_procs(cpus_t *cm, cpus_t *p,int c) {
+ int sz = 0 ;
+ cpus_t *r ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ if (cm->cpu[p->cpu[k]] == c) sz++ ;
+ }
+ r = cpus_create(sz) ;
+ int i = 0 ;
+ for (int k = 0 ; k < p->sz ; k++) {
+ int proc = p->cpu[k] ;
+ if (cm->cpu[proc] == c) r->cpu[i++] = proc ;
+ }
+ return r ;
+}
+
+static mapcore_t *inverse_procs(cpus_t *cm, cpus_t *p) {
+ int ncores = get_ncores(cm) ;
+ mapcore_t *r = malloc_check(sizeof(*r)) ;
+ r->ncores = ncores ;
+ r->core = malloc_check(sizeof(r->core[0])*ncores) ;
+ for (int c = 0 ; c < ncores ; c++) {
+ r->core[c] = get_core_procs(cm,p,c) ;
+ }
+ return r ;
+}
+
+static int get_node_sz(int *p) {
+ int r = 0 ;
+ while (*p++ >= 0) r++ ;
+ return r ;
+}
+
+static int get_n(int **p) {
+ int r = 0 ;
+ while (*p) {
+ r += get_node_sz(*p) ;
+ p++ ;
+ }
+ return r ;
+}
+
+static int ok_one_color(int *cm,int *d,int *a,int n, int p, int c) {
+ for (int k = 0 ; k < n ; k++) {
+ int op = a[k] ;
+ if (op >= 0) {
+ if (d[n*p+k]) {
+ int oc = cm[op] ;
+ if (oc == c) {
+ return 0 ;
+ }
+ }
+ }
+ }
+ return 1 ;
+}
+
+static int ok_color(int *cm,int *d,int *a,int n, int *q, int c) {
+ for ( ; *q >= 0 ; q++) {
+ if (!ok_one_color(cm,d,a,n,*q,c)) return 0 ;
+ }
+ return 1 ;
+}
+
+static int find_color_diff
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d, int *a,int n, int *q) {
+ int sz = get_node_sz(q) ;
+ int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
+ int k = k0 ;
+ do {
+ cpus_t *p = mc->core[k] ;
+ if (p->sz >= sz && ok_color(cm,d,a,n,q,k)) return k ;
+ k++ ; k %= mc->ncores ;
+ } while (k != k0) ;
+ return -1 ;
+}
+
+
+static int find_one_proc
+(int prev,st_t *st,int *cm,mapcore_t *mc,int *d,int *a,int n,int p) {
+ int found = -1 ;
+ int k0 = prev >= 0 && rand_bit(st) ? prev : rand_k(st,mc->ncores) ;
+ int k = k0 ;
+ do {
+ cpus_t *pk = mc->core[k] ;
+ if (pk->sz > 0) {
+ if (found < 0) found = k ;
+ if (ok_one_color(cm,d,a,n,p,k)) return k ;
+ }
+ k++ ; k %= mc->ncores ;
+ } while (k != k0) ;
+ if (found < 0) fatal("Cannot allocate threads") ;
+ return found ;
+}
+
+void custom_affinity (st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) {
+ mapcore_t *mc = inverse_procs(cm,aff_cpus) ;
+ int n = get_n(color) ;
+ /* Diff relation as matrix */
+ int d[n*n] ;
+ {
+ int *q = diff ;
+ for (int k = 0 ; k < n*n ; k++) d[k] = 0 ;
+ while (*q >= 0) {
+ int x = *q++, y = *q++ ;
+ d[n*x+y] = d[n*y+x] = 1 ;
+ }
+ }
+ for (int k = 0 ; k < n_exe ; k++) {
+ int *a = &r[k*n] ;
+ int prev_core = -1 ;
+ for (int i = 0 ; i < n ; i++) a[i] = -1 ;
+ for (int **q = color ; *q ; q++) {
+ int c = find_color_diff(prev_core,st,aff_cpus->cpu,mc,d,a,n,*q) ;
+ if (c >= 0) {
+ cpus_t *p = mc->core[c] ;
+ for (int *qq = *q ; *qq >= 0 ; qq++) {
+ p->sz-- ;
+ a[*qq] = p->cpu[p->sz] ;
+ }
+ prev_core = c ;
+ } else {
+ for (int *qq = *q ; *qq >= 0 ; qq++) {
+ int c = find_one_proc(prev_core,st,aff_cpus->cpu,mc,d,a,n,*qq) ;
+ cpus_t *p = mc->core[c] ;
+ p->sz-- ;
+ a[*qq] = p->cpu[p->sz] ;
+ prev_core = c ;
+ }
+ }
+ }
+ }
+ mapcore_free(mc) ;
+}
+
+/****************/
+/* Command line */
+/****************/
+
+/* usage */
+
+static void usage(char *prog, cmd_t *d) {
+ log_error("usage: %s (options)*\n",prog) ;
+ log_error(" -v be verbose\n") ;
+ log_error(" -q be quiet\n") ;
+ log_error(" -a <n> run maximal number of tests for n available processors (default %i)\n",d->avail) ;
+ log_error(" -n <n> run n tests concurrently\n") ;
+ log_error(" -r <n> perform n runs (default %i)\n",d->max_run) ;
+ log_error(" -fr <f> multiply run number per f\n") ;
+ log_error(" -s <n> outcomes per run (default %i)\n",d->size_of_test) ;
+ if (d->stride > 0) {
+ log_error(" -st <n> stride (default %i)\n",d->stride) ;
+ }
+ log_error(" -fs <f> multiply outcomes per f\n") ;
+ log_error(" -f <f> multiply outcomes per f, divide run number by f\n") ;
+ if (d->aff_mode != aff_none) {
+ log_error(" -i <n> increment for allocating logical processors, -i 0 disables affinity mode") ;
+ if (d->aff_mode == aff_incr) {
+ log_error(" (default %i)\n",d->aff_incr) ;
+ } else {
+ log_error("\n") ;
+ }
+ log_error(" -p <ns> specify logical processors (default '") ;
+ cpus_dump(errlog,d->aff_cpus) ;
+ log_error("')\n") ;
+ log_error(" +ra randomise affinity%s\n",d->aff_mode == aff_random ? " (default)" : "") ;
+ if (d->aff_custom_enabled) {
+ log_error(" +ca enable custom affinity%s\n",d->aff_mode == aff_custom ? " (default)" : "") ;
+ } else {
+ log_error(" +ca alias for +ra\n") ;
+ }
+ if (d->aff_scan_enabled) {
+ log_error(" +sa enable scanning affinity%s\n",d->aff_mode == aff_scan ? " (default)" : "") ;
+ log_error(" +ta <topo> set topology affinity\n") ;
+ } else {
+ log_error(" +sa alias for +ra\n") ;
+ }
+ }
+ if (d->shuffle >= 0) {
+ log_error(" +rm randomise memory accesses%s\n",d->shuffle ? " (default)" : "") ;
+ log_error(" -rm do not randomise memory accesses%s\n",!d->shuffle ? " (default)" : "") ;
+ }
+ if (d->speedcheck >= 0) {
+ log_error(" +sc stop as soon as possible%s\n",d->speedcheck ? " (default)" : "") ;
+ log_error(" -sc run test completly%s\n",!d->speedcheck ? " (default)" : "") ;
+ }
+ if (!d->fix) {
+ log_error(" +fix fix thread launch order\n") ;
+ }
+ if (d->delta_tb) {
+ log_error(" -tb <list> set timebase delays, default '") ;
+ ints_dump(errlog,d->delta_tb) ;
+ log_error("'\n") ;
+ log_error(" List syntax is comma separated proc:delay\n") ;
+ log_error(" -ta <n> set all timebase delays\n") ;
+ }
+ if (d->verbose_barrier >= 0) {
+ log_error(" +vb show iteration timings%s\n",d->verbose_barrier ? " (default)" : "") ;
+ log_error(" -vb do not show iteration timings%s\n",!d->verbose_barrier ? " (default)" : "") ;
+ }
+ if (d->prefetch) {
+ log_error(" -pra (I|F|T|W) set all prefetch\n") ;
+ log_error(" -prf <list> set prefetch, default '") ;
+ prefetch_dump(errlog,d->prefetch) ;
+ log_error("'\n") ;
+ log_error(" List syntax is comma separated proc:name=(I|F|T|W)\n") ;
+ }
+ if (d->static_prefetch >= 0) {
+ log_error(" -prs <n> prefetch probability is 1/n, -prs 0 disables feature, default %i\n",d->static_prefetch) ;
+ }
+ if (d->max_loop > 0) {
+ log_error(" -l <n> measure time by running assembly in a loop of size <n> (default %i)\n",d->max_loop) ;
+ }
+ if (d->prelude > 0) {
+ log_error(" -vp no verbose prelude\n") ;
+ }
+ if (d->sync_n > 0) {
+ log_error(" -k <n> undocumented (default %i)\n",d->sync_n) ;
+ }
+ exit(2) ;
+}
+
+static long my_add (long x, long y) {
+ long r = x+y ;
+ if (r < x || r < y) { errno = ERANGE ; fatal("overflow") ; }
+ return r ;
+}
+
+static long my_pow10(int p,long x) {
+ long r = x ;
+ for ( ; p > 0 ; p--) {
+ long y2 = my_add(r,r) ;
+ long y4 = my_add(y2,y2) ;
+ long y8 = my_add(y4,y4) ;
+ r = my_add(y8,y2) ;
+ }
+ if (r >= INT_MAX || r <= 0) { errno = ERANGE ; fatal("overflow") ; }
+ return r ;
+}
+
+static int do_argint(char *p, char **q) {
+ long r = strtol(p,q,10) ;
+ if (errno == ERANGE) { fatal("overflow") ; }
+ 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 ; }
+ return (int)r ;
+}
+
+static int argint(char *prog,char *p,cmd_t *d) {
+ char *q ;
+ long r = do_argint(p,&q) ;
+ if (*p == '\0' || *q != '\0') {
+ usage(prog,d) ;
+ }
+ return (int)r ;
+}
+
+static cpus_t *argcpus(char *prog,char *p0,cmd_t *d) {
+ int sz = 0 ;
+ char *p ;
+
+ p = p0 ;
+ for ( ; ; ) {
+ char *q ;
+ int x = (int)strtol(p,&q,10) ;
+ if (x < 0 || *p == '\0' || (*q != '\0' && *q != ',')) usage(prog,d) ;
+ sz++ ;
+ if (*q == '\0') break ;
+ p = q+1 ;
+ }
+ cpus_t *r = cpus_create(sz) ;
+ p = p0 ;
+ for (int k = 0 ; k < sz ; k++) {
+ char *q ;
+ r->cpu[k] = (int)strtol(p,&q,10) ;
+ p = q+1 ;
+ }
+ return r ;
+}
+
+static void argints(char *prog,cmd_t *d, char *p,ints_t *r) {
+ while (*p) {
+ char *q ;
+ int idx = (int)strtol(p,&q,10) ;
+ if (idx < 0 || idx >= r->sz || *p == '\0' || *q != ':') usage(prog,d) ;
+ p = q+1 ;
+ int v = do_argint(p,&q) ;
+ if (*p == '\0' || (*q != '\0' && *q != ',')) usage(prog,d) ;
+ r->t[idx] = v ;
+ if (*q == '\0') {
+ p = q ;
+ } else {
+ p = q+1 ;
+ }
+ }
+}
+
+static prfone_t *get_name_slot(prfproc_t *p,char *name) {
+ int nvars = p->nvars ;
+ prfone_t *q = p->t ;
+ for (int _v = 0 ; _v < nvars ; _v++) {
+ if (strcmp(name,q[_v].name) == 0) return &q[_v] ;
+ }
+ return NULL ; /* Name not found */
+}
+
+
+static void argoneprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
+ prfdir_t dir = none ;
+ switch (*p) {
+ case 'F':
+ dir = flush ;
+ break ;
+ case 'T':
+ dir = touch ;
+ break ;
+ case 'W':
+ dir = touch_store ;
+ break ;
+ }
+ set_prefetch(r,dir) ;
+}
+
+int parse_prefetch(char *p, prfdirs_t *r) {
+ if (!*p) return 1 ;
+ for ( ;; ) {
+ char *q ;
+ int proc = (int)strtol(p,&q,10) ;
+ if (proc < 0 || proc >= r->nthreads || *p == '\0' || *q != ':')
+ return 0 ;
+ p = q+1 ;
+ char *p0 = p ;
+ while (*p != '=') {
+ if (*p == '\0') return 0 ;
+ p++ ;
+ }
+ *p = '\0' ;
+ prfone_t *loc_slot = get_name_slot(&r->t[proc],p0) ;
+ if (loc_slot == NULL) {
+ log_error("Proc %i does not access variable %s\n",proc,p0) ;
+ *p = '=' ;
+ return 0 ;
+ }
+ *p = '=' ;
+ char c = *++p;
+ prfdir_t dir = none ;
+ switch (c) {
+ case 'F':
+ dir = flush ;
+ break ;
+ case 'T':
+ dir = touch ;
+ break ;
+ case 'W':
+ dir = touch_store ;
+ break ;
+ }
+ loc_slot->dir = dir ;
+ c = *++p ;
+ if (c == '\0') return 1 ;
+ else if (c == ',') p++ ;
+ else return 0 ;
+ }
+}
+
+static void argprefetch(char *prog,cmd_t *d, char *p, prfdirs_t *r) {
+ if (!parse_prefetch(p,r)) usage(prog,d) ;
+}
+
+static double argdouble(char *prog,char *p,cmd_t *d) {
+ char *q ;
+ double r = strtod(p,&q) ;
+ if (*p == '\0' || *q != '\0') {
+ usage(prog,d) ;
+ }
+ return r ;
+}
+
+void parse_cmd(int argc, char **argv, cmd_t *d, cmd_t *p) {
+ char *prog = argv[0] ;
+
+ /* Options */
+ for ( ; ; ) {
+ --argc ; ++argv ;
+ if (!*argv) break ;
+ char fst = **argv ;
+ if (fst != '-' && fst != '+') break ;
+ if (strcmp(*argv,"-q") == 0) p->verbose=0 ;
+ else if (strcmp(*argv,"-v") == 0) p->verbose++ ;
+ else if (strcmp(*argv,"-r") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->max_run = argint(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-fr") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->max_run *= argdouble(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-s") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->size_of_test = argint(prog,argv[0],d) ;
+ } else if (d->stride > 0 && strcmp(*argv,"-st") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->stride = argint(prog,argv[0],d) ;
+ if (p->stride <= 0) p->stride = 1 ;
+ } else if (strcmp(*argv,"-fs") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->size_of_test *= argdouble(prog,argv[0],d) ;
+ } else if (strcmp(*argv,"-f") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ double f = argdouble(prog,argv[0],d) ;
+ p->size_of_test *= f ;
+ p->max_run /= f ;
+ } else if (strcmp(*argv,"-n") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->n_exe = argint(prog,argv[0],d) ;
+ if (p->n_exe < 1) p->n_exe = 1 ;
+ } else if (strcmp(*argv,"-a") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int a = argint(prog,argv[0],d) ;
+ p->avail = a ;
+ } else if (d->sync_n > 0 && strcmp(*argv,"-k") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int a = argint(prog,argv[0],d) ;
+ p->sync_n = a < 0 ? 0 : a ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"-i") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int i = argint(prog,argv[0],d) ;
+ p->aff_mode = aff_incr ;
+ p->aff_incr = i < 0 ? 0 : i ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"-p") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ cpus_t *cpus = argcpus(prog,argv[0],d) ;
+ p->aff_cpus = cpus ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+ra") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_custom_enabled && strcmp(*argv,"+ca") == 0) {
+ p->aff_mode = aff_custom ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+ca") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_scan_enabled && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_scan ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->aff_scan_enabled && strcmp(*argv,"+ta") == 0) {
+ p->aff_mode = aff_topo ;
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ p->aff_topo = argv[0] ;
+ } else if (d->aff_mode != aff_none && strcmp(*argv,"+sa") == 0) {
+ p->aff_mode = aff_random ;
+ } else if (d->shuffle >= 0 && strcmp(*argv,"+rm") == 0) {
+ p->shuffle = 1 ;
+ } else if (d->shuffle >= 0 && strcmp(*argv,"-rm") == 0) {
+ p->shuffle = 0 ;
+ } else if (d->speedcheck >= 0 && strcmp(*argv,"+sc") == 0) {
+ p->speedcheck = 1 ;
+ } else if (d->speedcheck >= 0 && strcmp(*argv,"-sc") == 0) {
+ p->speedcheck = 0 ;
+ } else if (!d->fix && strcmp(*argv,"+fix") == 0) {
+ p->fix = 1 ;
+ } else if (d->verbose_barrier >= 0 && strcmp(*argv,"+vb") == 0) {
+ p->verbose_barrier++ ;
+ } else if (d->verbose_barrier >= 0 && strcmp(*argv,"-vb") == 0) {
+ p->verbose_barrier = 0 ;
+ } else if (d->prelude > 0 && strcmp(*argv,"-vp") == 0) {
+ p->prelude = 0 ;
+ } else if (d->delta_tb && strcmp(*argv,"-tb") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argints(prog,d,argv[0],p->delta_tb) ;
+ } else if (d->delta_tb && strcmp(*argv,"-ta") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int da = argint(prog,argv[0],d) ;
+ for (int k = 0 ; k < p->delta_tb->sz ; k++) p->delta_tb->t[k] = da ;
+ } else if (d->prefetch && strcmp(*argv,"-prf") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argprefetch(prog,d,argv[0],p->prefetch) ;
+ } else if (d->prefetch && strcmp(*argv,"-pra") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ argoneprefetch(prog,d,argv[0],p->prefetch) ;
+ } else if (d->static_prefetch >= 0 && strcmp(*argv,"-prs") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int prs = argint(prog,argv[0],d) ;
+ p->static_prefetch = prs >= 0 ? prs : 0 ;
+ } else if (d->max_loop > 0 && strcmp(*argv,"-l") == 0) {
+ --argc ; ++argv ;
+ if (!*argv) usage(prog,d) ;
+ int i = argint(prog,argv[0],d) ;
+ p->max_loop = i < 1 ? 1 : i ;
+ } else usage(prog,d) ;
+ }
+
+ /* Argument */
+ if (argc == 0) return ;
+ usage(prog,d) ;
+}
+
+/*************************/
+/* Concurrency utilities */
+/*************************/
+
+/* phread based mutex */
+
+pm_t *pm_create(void) {
+ pm_t *p = malloc_check(sizeof(*p)) ;
+ int ret = pthread_mutex_init(p,NULL) ;
+ if (ret) { errexit("mutex_init",ret) ; }
+ return p ;
+}
+
+void pm_free(pm_t *p) {
+ free(p) ;
+}
+
+void pm_lock(pm_t *m) {
+ int ret = pthread_mutex_lock(m) ;
+ if (ret) { errexit("mutex_lock",ret) ; }
+}
+
+void pm_unlock(pm_t *m) {
+ int ret = pthread_mutex_unlock(m) ;
+ if (ret) { errexit("mutex_unlock",ret) ; }
+}
+
+/* phread condition */
+
+pc_t *pc_create(void) {
+ pc_t *p = malloc_check(sizeof(*p)) ;
+ p->c_mutex = pm_create() ;
+ p->c_cond = malloc_check(sizeof(*(p->c_cond))) ;
+ int e = pthread_cond_init(p->c_cond,NULL) ;
+ if (e) { errexit("cond_init",e); }
+ return p ;
+}
+
+void pc_free(pc_t *p) {
+ pm_free(p->c_mutex) ;
+ free(p->c_cond) ;
+ free(p) ;
+}
+
+static void pc_lock(pc_t *p) {
+ pm_lock(p->c_mutex) ;
+}
+
+static void pc_unlock(pc_t *p) {
+ pm_unlock(p->c_mutex) ;
+}
+
+void pc_wait(pc_t *p) {
+ int e = pthread_cond_wait(p->c_cond, p->c_mutex) ;
+ if (e) { errexit("cond_wait",e) ; }
+}
+
+void pc_broadcast (pc_t *p) {
+ int e = pthread_cond_broadcast(p->c_cond) ;
+ if (e) { errexit("cond_broadcast",e) ; }
+}
+
+static void pc_signal(pc_t *p) {
+ int e = pthread_cond_signal(p->c_cond);
+ if (e) errexit("cond_signal",e) ;
+}
+
+
+/* pthread based barrier, usable for nproc threads */
+
+
+pb_t *pb_create(int nprocs) {
+ pb_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->count = p->nprocs = nprocs ;
+ p->turn = 0 ;
+ return p ;
+}
+
+void pb_free(pb_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+/* The following code should protect us against spurious wake ups */
+void pb_wait(pb_t *p) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ pc_unlock(p->cond) ;
+}
+
+
+/* pthread based or flag */
+
+po_t *po_create(int nprocs) {
+ po_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->nprocs = p->count = nprocs ;
+ p->val = 0 ;
+ p->turn = 0 ;
+ return p ;
+}
+
+void po_free(po_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+void po_reinit(po_t *p) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->val = 0 ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ pc_unlock(p->cond) ;
+}
+
+int po_wait(po_t *p, int v) {
+ pc_lock(p->cond) ;
+ int t = p->turn ;
+ --p->count ;
+ p->val = p->val || v ;
+ if (p->count == 0) {
+ p->count = p->nprocs ;
+ p->turn = !t ;
+ pc_broadcast(p->cond) ;
+ } else {
+ do {
+ pc_wait(p->cond) ;
+ } while (p->turn == t) ;
+ }
+ int r = p->val ;
+ pc_unlock(p->cond) ;
+ return r ;
+}
+
+
+/* One place buffer */
+
+op_t *op_create(void) {
+ op_t *p = malloc_check(sizeof(*p)) ;
+ p->cond = pc_create() ;
+ p->val = NULL ;
+ p->some = 0 ;
+ return p;
+}
+
+void op_free(op_t *p) {
+ pc_free(p->cond) ;
+ free(p) ;
+}
+
+void op_set(op_t *p, void *v) {
+ pc_lock(p->cond) ;
+ if (p->some) { fatal("op_set") ; }
+ p->val = v ;
+ p->some = 1 ;
+ pc_signal(p->cond) ;
+ pc_unlock(p->cond) ;
+}
+
+void *op_get(op_t *p) {
+ void *v = NULL ;
+ pc_lock(p->cond) ;
+ while (!p->some) {
+ pc_wait(p->cond) ;
+ }
+ v = (void *) p->val ;
+ p->val = NULL ;
+ p->some = 0 ;
+ pc_unlock(p->cond) ;
+ return v ;
+}
+
+/* Thread launch and join */
+
+void launch(pthread_t *th, f_t *f, void *a) {
+ int e = pthread_create(th,NULL,f,a);
+ if (e) errexit("phread_create",e);
+}
+
+void *join(pthread_t *th) {
+ void *r ;
+ int e = pthread_join(*th,&r) ;
+ if (e) errexit("pthread_join",e);
+ return r ;
+}
+
+/* Detached */
+
+typedef struct {
+ f_t *f;
+ void *a ;
+ op_t *op;
+} detarg_t ;
+
+static void *zyva_det(void *_b) {
+ detarg_t *b = (detarg_t *)_b;
+ f_t *f = b->f ;
+ void *a = b->a ;
+ op_t *op = b->op ;
+ free(b) ;
+ int e = pthread_detach(pthread_self());
+ if (e) errexit("pthread_detach",e) ;
+ void *r = f(a) ;
+ op_set(op,r) ;
+ return NULL ;
+}
+
+op_t *launch_detached(f_t *f,void *a) {
+ op_t *op = op_create() ;
+ detarg_t *b = malloc_check(sizeof(*b)) ;
+ b->f = f ; b->a = a; b->op = op ;
+ pthread_t th ;
+ launch(&th,zyva_det,b) ;
+ return op ;
+}
+
+void *join_detached(op_t *op) {
+ void *r = op_get(op) ;
+ op_free(op) ;
+ return r ;
+}
+
+/* Thread cache */
+
+void *start_thread(void *_a) {
+ sarg_t *_b = (sarg_t *)_a ;
+ for (int _k = _b->max_run ; _k > 0 ; _k--) {
+ void *_c = op_get(_b->op_arg) ;
+ f_t *f = (f_t *)_c ;
+ if (f == NULL) break ;
+ void *ret = f(_b->arg) ;
+ op_set(_b->op_ret,ret) ;
+ }
+ return NULL ;
+}
+
+/*****************/
+/* Random things */
+/*****************/
+
+void perm_prefix_ints(unsigned *st,int *_t, int m, int n) {
+ int k;
+ for (k = 0 ; k < m ; k++) {
+ int j = k+rand_k(st,n-k);
+ int x = _t[k]; _t[k] = _t[j]; _t[j] = x;
+ }
+}
+
+void perm_ints(unsigned *st,int *_t, int n) {
+ perm_prefix_ints(st, _t,n-1,n) ;
+}
+
+void perm_funs(unsigned *st,f_t *fun[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ f_t *t = fun[j];
+ fun[j] = fun[k]; fun[k] = t;
+ }
+}
+
+void perm_ops(unsigned *st,op_t *op[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ op_t *t = op[j];
+ op[j] = op[k]; op[k] = t;
+ }
+}
+
+void perm_threads(unsigned *st,pthread_t thread[], int n) {
+ int k;
+ for (k = 0 ; k < n-1 ; k++) {
+ int j = k+rand_k(st,n-k);
+ pthread_t t = thread[j];
+ thread[j] = thread[k]; thread[k] = t;
+ }
+}
+
+static int int_cmp(const void *_p, const void *_q) {
+ int x = *((int *)_p) ;
+ int y = *((int *)_q) ;
+ if (x < y) return -1 ;
+ else if (x > y) return 1 ;
+ else return 0 ;
+}
+
+int check_shuffle(int **t, int *min, int sz) {
+ int *idx = malloc_check(sizeof(*idx)*sz) ;
+ for (int k=0 ; k < sz ; k++) {
+ idx[k] = (int)(t[k] - min) ;
+ // fprintf(stderr," %i",idx[k]) ;
+ }
+ // fprintf(stderr,"\n") ;
+ qsort(&idx[0],sz, sizeof(idx[0]), int_cmp) ;
+ for (int k=0 ; k < sz ; k++) {
+ if (idx[k] != k) {
+ free(idx) ;
+ return 0 ;
+ }
+ }
+ free(idx) ;
+ return 1 ;
+}
+
+/****************/
+/* Time counter */
+/****************/
+
+#include <sys/time.h>
+#include <time.h>
+
+tsc_t timeofday(void) {
+ struct timeval tv ;
+ if (gettimeofday(&tv,NULL)) errexit("gettimeoday",errno) ;
+ return tv.tv_sec * ((tsc_t)1000000) + tv.tv_usec ;
+}
+
+double tsc_ratio(tsc_t t1, tsc_t t2) {
+ return ((double) t1) / ((double)t2) ;
+}
+
+
+double tsc_millions(tsc_t t) {
+ return t / 1000000.0 ;
+}
+
+/*******************/
+/* String handling */
+/*******************/
+
+int find_string(char *t[], int sz, char *s) {
+ for (int k = 0 ; k < sz ; k++) {
+ if (strcmp(t[k],s) == 0) return k ;
+ }
+ return -1 ;
+}
diff --git a/tests/tcg/aarch64/litmus/utils.h b/tests/tcg/aarch64/litmus/utils.h
new file mode 100644
index 0000000..99e756e
--- /dev/null
+++ b/tests/tcg/aarch64/litmus/utils.h
@@ -0,0 +1,275 @@
+/****************************************************************************/
+/* the diy toolsuite */
+/* */
+/* Jade Alglave, University College London, UK. */
+/* Luc Maranget, INRIA Paris-Rocquencourt, France. */
+/* */
+/* Copyright 2015-present Institut National de Recherche en Informatique et */
+/* en Automatique and the authors. All rights reserved. */
+/* */
+/* This software is governed by the CeCILL-B license under French law and */
+/* abiding by the rules of distribution of free software. You can use, */
+/* modify and/ or redistribute the software under the terms of the CeCILL-B */
+/* license as circulated by CEA, CNRS and INRIA at the following URL */
+/* "http://www.cecill.info". We also give a copy in LICENSE.txt. */
+/****************************************************************************/
+#ifndef _UTILS_H
+#define _UTILS_H 1
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include "litmus_rand.h"
+
+
+/********/
+/* Misc */
+/********/
+
+void seterrlog(FILE *chan) ;
+
+int log_error(const char *fmt,...) ;
+
+void fatal(char *msg) ;
+/* e is errno */
+void errexit(char *msg,int e) ;
+
+void *malloc_check(size_t sz) ;
+
+int max(int n,int m) ;
+
+void pp_ints (FILE *fp,int *p,int n) ;
+
+void *do_align(void *p, size_t sz) ;
+
+void *do_noalign(void *p, size_t sz) ;
+
+void cat_file(char *path,char *msg,FILE *out) ;
+
+/***********/
+/* CPU set */
+/***********/
+
+#define CPUS_DEFINED 1
+typedef struct {
+ int sz ;
+ int *cpu ;
+} cpus_t ;
+
+cpus_t *cpus_create(int sz) ;
+cpus_t *cpus_create_init(int sz, int t[]) ;
+void cpus_free(cpus_t *p) ;
+void cpus_dump(FILE *fp, cpus_t *p) ;
+void cpus_dump_test(FILE *fp, int *p, int sz, cpus_t *cm,int nprocs) ;
+
+int gcd(int a, int b) ;
+
+cpus_t *coremap_seq(int navail, int nways) ;
+cpus_t *coremap_end(int navail, int nways) ;
+
+void custom_affinity
+(st_t *st,cpus_t *cm,int **color,int *diff,cpus_t *aff_cpus,int n_exe, int *r) ;
+
+/*************/
+/* Int array */
+/*************/
+
+typedef struct {
+ int sz ;
+ int *t ;
+} ints_t ;
+
+void ints_dump(FILE *fp, ints_t *p) ;
+
+/* Prefetch directives */
+typedef enum {none, flush, touch, touch_store} prfdir_t ;
+
+typedef struct {
+ char *name ;
+ prfdir_t dir ;
+} prfone_t ;
+
+typedef struct {
+ int nvars ;
+ prfone_t *t ;
+} prfproc_t ;
+
+typedef struct {
+ int nthreads ;
+ prfproc_t *t ;
+} prfdirs_t ;
+
+void prefetch_dump(FILE *fp, prfdirs_t *p) ;
+int parse_prefetch(char *p, prfdirs_t *r) ;
+
+/************************/
+/* Command line options */
+/************************/
+typedef enum
+ { aff_none, aff_incr, aff_random, aff_custom,
+ aff_scan, aff_topo} aff_mode_t ;
+
+typedef struct {
+ int verbose ;
+ /* Test parmeters */
+ int max_run ;
+ int size_of_test ;
+ int stride ;
+ int avail ;
+ int n_exe ;
+ int sync_n ;
+ /* Affinity */
+ aff_mode_t aff_mode ;
+ int aff_custom_enabled ;
+ int aff_scan_enabled ;
+ int aff_incr ;
+ cpus_t *aff_cpus ;
+ char *aff_topo ;
+ /* indirect mode */
+ int shuffle ;
+ /* loop test */
+ int max_loop ;
+ /* time base delays */
+ ints_t * delta_tb ;
+ /* prefetch control */
+ prfdirs_t *prefetch ;
+ int static_prefetch ;
+ /* show time of synchronisation */
+ int verbose_barrier ;
+ /* Stop as soon as condition is settled */
+ int speedcheck ;
+ /* Enforce fixed launch order (ie cancel change lauch) */
+ int fix ;
+ /* Dump prelude to test output */
+ int prelude ;
+} cmd_t ;
+
+void parse_cmd(int argc, char **argv, cmd_t *def, cmd_t *p) ;
+
+
+/********************/
+/* Thread utilities */
+/********************/
+
+/* Mutex */
+
+typedef pthread_mutex_t pm_t ;
+
+pm_t *pm_create(void) ;
+void pm_free(pm_t *p) ;
+void pm_lock(pm_t *m) ;
+void pm_unlock(pm_t *m) ;
+
+/* Condition variable */
+
+typedef struct {
+ pm_t *c_mutex ;
+ pthread_cond_t *c_cond ;
+} pc_t ;
+
+pc_t *pc_create(void) ;
+void pc_free(pc_t *p) ;
+void pc_wait(pc_t *p) ;
+void pc_broadcast (pc_t *p) ;
+
+/* Barrier */
+
+/* Avoid pthread supplied barrier as they are not available in old versions */
+
+typedef struct {
+ volatile unsigned int count ;
+ volatile int turn ;
+ pc_t *cond ;
+ unsigned int nprocs ;
+} pb_t ;
+
+
+pb_t *pb_create(int nprocs) ;
+void pb_free(pb_t *p) ;
+void pb_wait(pb_t *p) ;
+
+
+/* Or flag */
+
+typedef struct {
+ pc_t *cond ;
+ int nprocs ;
+ int count ;
+ volatile int val ;
+ volatile int turn ;
+} po_t ;
+
+po_t *po_create(int nprocs) ;
+void po_free(po_t *p) ;
+/* Initialize flag, must be called by all participant */
+void po_reinit(po_t *p) ;
+/* Return the 'or' of the v arguments of all participants */
+int po_wait(po_t *p, int v) ;
+
+/* One place buffer */
+
+typedef struct {
+ pc_t *cond ;
+ int volatile some ;
+ void * volatile val ;
+} op_t ;
+
+op_t *op_create(void) ;
+void op_free(op_t *p) ;
+void op_set(op_t *p, void *v) ;
+void *op_get(op_t *p) ;
+
+/* Thread launch and join */
+
+typedef void* f_t(void *);
+
+void launch(pthread_t *th, f_t *f, void *a) ;
+
+void *join(pthread_t *th) ;
+
+/* Detached lauch and join */
+
+op_t *launch_detached(f_t *f,void *a) ;
+void *join_detached(op_t *p) ;
+
+/* Thread cache */
+
+typedef struct {
+ int max_run ;
+ op_t *op_arg,*op_ret ;
+ void *arg ;
+} sarg_t ;
+
+f_t start_thread ;
+
+/*****************/
+/* Random things */
+/*****************/
+
+/* permutations */
+
+void perm_prefix_ints(st_t *st,int t[], int used, int sz) ;
+void perm_ints(st_t *st,int t[], int sz) ;
+void perm_funs(st_t *st,f_t *t[], int sz) ;
+void perm_threads(st_t *st,pthread_t t[], int sz) ;
+void perm_ops(st_t *st,op_t *t[], int sz) ;
+
+/* check permutation */
+int check_shuffle(int **t, int *min, int sz) ;
+
+/*********************/
+/* Real time counter */
+/*********************/
+
+typedef unsigned long long tsc_t ;
+#define PTSC "%llu"
+
+/* Result in micro-seconds */
+tsc_t timeofday(void) ;
+double tsc_ratio(tsc_t t1, tsc_t t2) ;
+double tsc_millions(tsc_t t) ;
+
+/* String utilities */
+int find_string(char *t[],int sz,char *s) ;
+
+#endif
--
2.9.3
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [Qemu-devel] [PATCH v2 3/3] travis: Enable litmus tests
2016-08-20 16:28 [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 1/3] tests/tcg: Add i386 litmus test Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 2/3] tests/tcg: Add aarch64 litmus tests Pranith Kumar
@ 2016-08-20 16:28 ` Pranith Kumar
2016-08-20 21:19 ` [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests no-reply
3 siblings, 0 replies; 5+ messages in thread
From: Pranith Kumar @ 2016-08-20 16:28 UTC (permalink / raw)
To: qemu-devel, Alex Bennée
Enable running the litmus tests on travis.
Signed-off-by: Pranith Kumar <bobby.prani@gmail.com>
---
.travis.yml | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/.travis.yml b/.travis.yml
index f30b10e..f670c71 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -97,5 +97,13 @@ matrix:
before_install:
- sudo apt-get update -qq
- sudo apt-get build-dep -qq qemu
+ - sudo apt-get install gcc-aarch64-linux-gnu
- wget -O - http://people.linaro.org/~alex.bennee/qemu-submodule-git-seed.tar.xz | tar -xvJ
- git submodule update --init --recursive
+ after_success:
+ - cd tests/tcg/i386/litmus
+ - export QEMU=../../../../x86_64-linux-user/qemu-x86_64
+ - make tests
+ - cd ../../aarch64/litmus
+ - export QEMU=../../../../aarch64-linux-user/qemu-aarch64
+ - make tests
--
2.9.3
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests
2016-08-20 16:28 [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests Pranith Kumar
` (2 preceding siblings ...)
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 3/3] travis: Enable " Pranith Kumar
@ 2016-08-20 21:19 ` no-reply
3 siblings, 0 replies; 5+ messages in thread
From: no-reply @ 2016-08-20 21:19 UTC (permalink / raw)
To: bobby.prani; +Cc: famz, qemu-devel, alex.bennee
Hi,
Your series seems to have some coding style problems. See output below for
more information:
Message-id: 20160820162846.13501-1-bobby.prani@gmail.com
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/20160820162846.13501-1-bobby.prani@gmail.com -> patchew/20160820162846.13501-1-bobby.prani@gmail.com
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 patchew-devel@freelists.org
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2016-08-20 21:21 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2016-08-20 16:28 [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 1/3] tests/tcg: Add i386 litmus test Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 2/3] tests/tcg: Add aarch64 litmus tests Pranith Kumar
2016-08-20 16:28 ` [Qemu-devel] [PATCH v2 3/3] travis: Enable " Pranith Kumar
2016-08-20 21:19 ` [Qemu-devel] [PATCH v2 0/3] Add litmus tests for MTTCG consistency tests no-reply
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).