Hi Jeevitha, On 02/07/25 11:50 am, jeevitha wrote: > diff --git a/gcc/testsuite/gcc.target/powerpc/amo3.c > b/gcc/testsuite/gcc.target/powerpc/amo3.c > new file mode 100644 > index 00000000000..ac27543e2dc > --- /dev/null > +++ b/gcc/testsuite/gcc.target/powerpc/amo3.c > @@ -0,0 +1,134 @@ > +/* { dg-do compile { target { lp64 } } } */ > +/* { dg-options "-mdejagnu-cpu=power9 -O2" } */ > + > +/* This test uses uint64_t types. lp64 is added to avoid running it on 32-bit > + target. The test is skipped on 32-bit systems. */ > + > +/* Test whether the ISA 3.0 amo (atomic memory operations) functions perform > as > + expected. */ > + > +#include <amo.h> > +#include <stdint.h> > + > +uint32_t > +do_lw_cs_ne (uint32_t *mem, uint32_t cond, uint32_t value) > +{ > + return amo_lwat_cas_neq (mem, cond, value); > +} > + > +int32_t > +do_lw_scs_ne (int32_t *mem, int32_t cond, int32_t value) > +{ > + return amo_lwat_scas_neq (mem, cond, value); > +} > + > +uint32_t > +do_lw_inc_equal (uint32_t *mem) > +{ > + return amo_lwat_inc_eq (mem); > +} > + > +int32_t > +do_lw_sinc_equal (int32_t *mem) > +{ > + return amo_lwat_sinc_eq (mem); > +} > + > +uint32_t > +do_lw_inc_bounded (uint32_t *mem) > +{ > + return amo_lwat_inc_bounded (mem); > +} > + > +int32_t > +do_lw_sinc_bounded (int32_t *mem) > +{ > + return amo_lwat_sinc_bounded (mem); > +} > +uint32_t > +do_lw_dec_bounded (uint32_t *mem) > +{ > + return amo_lwat_dec_bounded (mem); > +} > + > +int32_t > +do_lw_sdec_bounded (int32_t *mem) > +{ > + return amo_lwat_sdec_bounded (mem); > +} > + > +uint64_t > +do_ld_cs_ne (uint64_t *mem, uint64_t cond, uint64_t value) > +{ > + return amo_ldat_cas_neq (mem, cond, value); > +} > + > +int64_t > +do_ld_scs_ne (int64_t *mem, int64_t cond, int64_t value) > +{ > + return amo_ldat_scas_neq (mem, cond, value); > +} > + > +uint64_t > +do_ld_inc_equal (uint64_t *mem) > +{ > + return amo_ldat_inc_eq (mem); > +} > + > +int64_t > +do_ld_sinc_equal (int64_t *mem) > +{ > + return amo_ldat_sinc_eq (mem); > +} > + > +uint64_t > +do_ld_inc_bounded (uint64_t *mem) > +{ > + return amo_ldat_inc_bounded (mem); > +} > + > +int64_t > +do_ld_sinc_bounded (int64_t *mem) > +{ > + return amo_ldat_sinc_bounded (mem); > +} > +uint64_t > +do_ld_dec_bounded (uint64_t *mem) > +{ > + return amo_ldat_dec_bounded (mem); > +} > + > +int64_t > +do_ld_sdec_bounded (int64_t *mem) > +{ > + return amo_ldat_sdec_bounded (mem); > +} > + > +void > +do_sw_twin (uint32_t *mem, uint32_t value) > +{ > + amo_stwat_twin (mem, value); > +} > + > +void > +do_sw_stwin (int32_t *mem, int32_t value) > +{ > + amo_stwat_stwin (mem, value); > +} > + > +void > +do_sd_twin (uint64_t *mem, uint64_t value) > +{ > + amo_stdat_twin (mem, value); > +} > + > +void > +do_sd_stwin (int64_t *mem, int64_t value) > +{ > + amo_stdat_stwin (mem, value); > +} > + > +/* { dg-final { scan-assembler-times {\mldat\M} 8 } } */ > +/* { dg-final { scan-assembler-times {\mlwat\M} 8 } } */ > +/* { dg-final { scan-assembler-times {\mstdat\M} 2 } } */ > +/* { dg-final { scan-assembler-times {\mstwat\M} 2 } } */ > diff --git a/gcc/testsuite/gcc.target/powerpc/amo4.c > b/gcc/testsuite/gcc.target/powerpc/amo4.c > new file mode 100644 > index 00000000000..4138f63a9f0 > --- /dev/null > +++ b/gcc/testsuite/gcc.target/powerpc/amo4.c > @@ -0,0 +1,94 @@ > +/* { dg-do run { target { lp64 && p9vector_hw } } } */ > +/* { dg-options "-mdejagnu-cpu=power9 -O2" } */ > + > +/* This test uses uint64_t types. lp64 is added to avoid running it on 32-bit > + target. The test is skipped on 32-bit systems. */ > + > +#include <amo.h> > +#include <stdint.h> > +#include <stdlib.h> > +#include <limits.h> > + > +/* Test whether the ISA 3.0 amo (atomic memory operations) functions perform > as > + expected. */ > + > +/* 32-bit tests. */ > +static uint32_t u32_ld[4][2] = { > + { 10, 15 }, /* Increment Bounded */ > + { 10, 10 }, /* Increment Bounded */ > + { 10, 10 }, /* Increment Equal */ > + { 10, 15 } /* Increment Equal */ > +}; > + > +static uint32_t u32_result[4]; > + > +static uint32_t u32_update[4] = { > + 10 + 1, /* Increment Bounded */ > + 10, /* Increment Bounded */ > + 10 + 1, /* Increment Equal */ > + 10 /* Increment Equal */ > +}; > + > +static uint32_t u32_prev[4] = { > + 10, /* Increment Bounded */ > + INT_MIN, /* Increment Bounded */ > + 10, /* Increment Equal */ > + INT_MIN /* Increment Equal */ > +}; > +
The name 'u32_prev' doesn't reflect what it actually means. Better name would be u32_expected_result. And u32_result can be named as u32_actual_result. Ditto for u64_prev and u64_result. > +/* 64-bit tests. */ > +static uint64_t u64_ld[4][2] = { > + { 10, 15 }, /* Increment Bounded */ > + { 10, 10 }, /* Increment Bounded */ > + { 10, 10 }, /* Increment Equal */ > + { 10, 15 } /* Increment Equal */ > +}; > + > +static uint64_t u64_result[4]; > + > +static uint64_t u64_update[4] = { > + 10 + 1, /* Increment Bounded */ > + 10, /* Increment Bounded */ > + 10 + 1, /* Increment Equal */ > + 10 /* Increment Equal */ > +}; > + > +static uint64_t u64_prev[4] = { > + 10, /* Increment Bounded */ > + INT64_MIN, /* Increment Bounded */ > + 10, /* Increment Equal */ > + INT64_MIN /* Increment Equal */ > +}; > + > +int > +main (void) > +{ > + size_t i; > + > + u32_result[0] = amo_lwat_inc_bounded (&u32_ld[0][0]); > + u32_result[1] = amo_lwat_inc_bounded (&u32_ld[1][0]); > + u32_result[2] = amo_lwat_inc_eq (&u32_ld[2][0]); > + u32_result[3] = amo_lwat_inc_eq (&u32_ld[3][0]); > + > + u64_result[0] = amo_ldat_inc_bounded (&u64_ld[0][0]); > + u64_result[1] = amo_ldat_inc_bounded (&u64_ld[1][0]); > + u64_result[2] = amo_ldat_inc_eq (&u64_ld[2][0]); > + u64_result[3] = amo_ldat_inc_eq (&u64_ld[3][0]); > + > + for (i = 0; i < 4; i++) > + { > + if (u32_result[i] != u32_prev[i]) > + abort (); > + > + if (u32_ld[i][0] != u32_update[i]) > + abort (); > + > + if (u64_result[i] != u64_prev[i]) > + abort (); > + > + if (u64_ld[i][0] != u64_update[i]) > + abort (); > + } > + > + return 0; > +} > diff --git a/gcc/testsuite/gcc.target/powerpc/amo5.c > b/gcc/testsuite/gcc.target/powerpc/amo5.c > new file mode 100644 > index 00000000000..dae55fc755d > --- /dev/null > +++ b/gcc/testsuite/gcc.target/powerpc/amo5.c > @@ -0,0 +1,46 @@ > +/* { dg-do run { target { lp64 && p9vector_hw } } } */ > +/* { dg-options "-mdejagnu-cpu=power9 -O2" } */ > + > +/* This test uses uint64_t types. lp64 is added to avoid running it on 32-bit > + target. The test is skipped on 32-bit systems. */ > + > +#include <amo.h> > +#include <stdint.h> > +#include <stdlib.h> > +#include <limits.h> > + > +/* Test whether the ISA 3.0 amo (atomic memory operations) functions perform > as > + expected. */ > + > +int > +main (void) > +{ > + static uint32_t u32_mem = 100; > + static uint32_t u32_cond = 200; > + static uint32_t u32_value = 250; > + static uint32_t u32_prev = 100; > + static uint32_t u32_result; > + > + static uint64_t u64_mem = 200; > + static uint64_t u64_cond = 300; > + static uint64_t u64_value = 250; > + static uint64_t u64_prev = 200; > + static uint64_t u64_result; This test is testing the case where "mem(EA,s) != (RT+1)". Please add tests to check for the case where the != condition fails. > + > + u32_result = amo_lwat_cas_neq (&u32_mem, u32_cond, u32_value); > + u64_result = amo_ldat_cas_neq (&u64_mem, u64_cond, u64_value); > + > + if (u32_mem != u32_value) > + abort(); > + > + if (u32_result != u32_prev) > + abort(); > + > + if (u64_mem != u64_value) > + abort(); > + > + if (u64_result != u64_prev) > + abort(); > + > + return 0; > + } > diff --git a/gcc/testsuite/gcc.target/powerpc/amo6.c > b/gcc/testsuite/gcc.target/powerpc/amo6.c > new file mode 100644 > index 00000000000..ae68ebaa280 > --- /dev/null > +++ b/gcc/testsuite/gcc.target/powerpc/amo6.c > @@ -0,0 +1,42 @@ > +/* { dg-do run { target { lp64 && p9vector_hw } } } */ > +/* { dg-options "-mdejagnu-cpu=power9 -O2" } */ > + > +/* This test uses uint64_t types. lp64 is added to avoid running it on 32-bit > + target. The test is skipped on 32-bit systems. */ > + > +#include <amo.h> > +#include <stdint.h> > +#include <stdlib.h> > +#include <limits.h> > + > +/* Test whether the ISA 3.0 amo (atomic memory operations) functions perform > as > + expected. */ > + > +int > +main (void) > +{ > + size_t i; > + static uint32_t u32_mem[2] = { 3, 3 }; > + static uint32_t u32_value = 5; > + static uint32_t u32_prev[2] = { 3, 3 }; > + static uint32_t u32_result; > + > + static uint64_t u64_mem[2] = { 7, 7 }; > + static uint64_t u64_value = 9; > + static uint64_t u64_prev[2] = { 7, 7 }; > + static uint64_t u64_result; The variables u32_prev, u32_result, u64_prev and u64_result are not used. They can be removed. Please add test to check for the case where mem(EA,s) != mem(EA+s,s). > + > + amo_stwat_twin (u32_mem, u32_value); > + amo_stdat_twin (u64_mem, u64_value); > + > + for ( i = 0; i < 2; i++) > + { > + if (u32_mem[i] != u32_value) > + abort(); > + > + if (u64_mem[i] != u64_value) > + abort(); > + } > + > + return 0; > + } > diff --git a/gcc/testsuite/gcc.target/powerpc/amo7.c > b/gcc/testsuite/gcc.target/powerpc/amo7.c > new file mode 100644 > index 00000000000..183125f6f97 > --- /dev/null > +++ b/gcc/testsuite/gcc.target/powerpc/amo7.c > @@ -0,0 +1,78 @@ > +/* { dg-do run { target { lp64 && p9vector_hw } } } */ > +/* { dg-options "-mdejagnu-cpu=power9 -O2" } */ > + > +/* This test uses uint64_t types. lp64 is added to avoid running it on 32-bit > + target. The test is skipped on 32-bit systems. */ > + > +#include <amo.h> > +#include <stdint.h> > +#include <stdlib.h> > +#include <limits.h> > + > +/* Test whether the ISA 3.0 amo (atomic memory operations) functions perform > as > + expected. */ > + > +/* 32-bit tests. */ > +static uint32_t u32_ld[2][2] = { > + { 10, 15 }, /* Decrement Bounded */ > + { 10, 10 }, /* Decrement Bounded */ > +}; > + > +static uint32_t u32_result[2]; > + > +static uint32_t u32_update[2] = { > + 15 - 1, /* Decrement Bounded */ > + 10, /* Decrement Bounded */ > +}; > + > +static uint32_t u32_prev[2] = { > + 15, /* Decrement Bounded */ > + INT_MIN, /* Decrement Bounded */ > +}; Here too, please rename 'u32_prev' and 'u64_prev' to what they actually mean. Regards, Surya > + > +/* 64-bit tests. */ > +static uint64_t u64_ld[2][2] = { > + { 10, 15 }, /* Decrement Bounded */ > + { 10, 10 }, /* Decrement Bounded */ > +}; > + > +static uint64_t u64_result[2]; > + > +static uint64_t u64_update[2] = { > + 15 - 1, /* Decrement Bounded */ > + 10, /* Decrement Bounded */ > +}; > + > +static uint64_t u64_prev[2] = { > + 15, /* Decrement Bounded */ > + INT64_MIN, /* Decrement Bounded */ > +}; > + > +int > +main (void) > +{ > + size_t i; > + > + u32_result[0] = amo_lwat_dec_bounded (&u32_ld[0][0]); > + u32_result[1] = amo_lwat_dec_bounded (&u32_ld[1][0]); > + > + u64_result[0] = amo_ldat_dec_bounded (&u64_ld[0][0]); > + u64_result[1] = amo_ldat_dec_bounded (&u64_ld[1][0]); > + > + for (i = 0; i < 2; i++) > + { > + if (u32_result[i] != u32_prev[i]) > + abort (); > + > + if (u32_ld[i][1] != u32_update[i]) > + abort (); > + > + if (u64_result[i] != u64_prev[i]) > + abort (); > + > + if (u64_ld[i][1] != u64_update[i]) > + abort (); > + } > + > + return 0; > +} >