1 /* Test of allocating memory with given alignment.
3 Copyright (C) 2020-2024 Free Software Foundation, Inc.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
18 /* Written by Bruno Haible <bruno@clisp.org>, 2020. */
31 #define ROUNDUP(x,y) (((x) + (y) - 1) & - (y))
34 main (int argc
, char *argv
[])
36 #if HAVE_ALIGNED_ALLOC
37 static size_t sizes
[] =
38 { 13, 8, 17, 450, 320, 1, 99, 4, 15, 16, 2, 76, 37, 127, 2406, 641, 5781 };
39 void *volatile aligned2_blocks
[SIZEOF (sizes
)];
40 void *volatile aligned4_blocks
[SIZEOF (sizes
)];
41 void *volatile aligned8_blocks
[SIZEOF (sizes
)];
42 void *volatile aligned16_blocks
[SIZEOF (sizes
)];
43 void *volatile aligned32_blocks
[SIZEOF (sizes
)];
44 void *volatile aligned64_blocks
[SIZEOF (sizes
)];
47 for (i
= 0; i
< SIZEOF (sizes
); i
++)
49 size_t size
= sizes
[i
];
51 aligned2_blocks
[i
] = aligned_alloc (2, ROUNDUP (size
, 2));
52 ASSERT (aligned2_blocks
[i
] != NULL
);
53 ASSERT (((uintptr_t) aligned2_blocks
[i
] % 2) == 0);
54 memset (aligned2_blocks
[i
], 'u', size
);
56 aligned4_blocks
[i
] = aligned_alloc (4, ROUNDUP (size
, 4));
57 ASSERT (aligned4_blocks
[i
] != NULL
);
58 ASSERT (((uintptr_t) aligned4_blocks
[i
] % 4) == 0);
59 memset (aligned4_blocks
[i
], 'v', size
);
61 aligned8_blocks
[i
] = aligned_alloc (8, ROUNDUP (size
, 8));
62 ASSERT (aligned8_blocks
[i
] != NULL
);
63 ASSERT (((uintptr_t) aligned8_blocks
[i
] % 8) == 0);
64 memset (aligned8_blocks
[i
], 'w', size
);
66 aligned16_blocks
[i
] = aligned_alloc (16, ROUNDUP (size
, 16));
67 ASSERT (aligned16_blocks
[i
] != NULL
);
68 ASSERT (((uintptr_t) aligned16_blocks
[i
] % 16) == 0);
69 memset (aligned16_blocks
[i
], 'x', size
);
71 aligned32_blocks
[i
] = aligned_alloc (32, ROUNDUP (size
, 32));
72 ASSERT (aligned32_blocks
[i
] != NULL
);
73 ASSERT (((uintptr_t) aligned32_blocks
[i
] % 32) == 0);
74 memset (aligned32_blocks
[i
], 'y', size
);
76 aligned64_blocks
[i
] = aligned_alloc (64, ROUNDUP (size
, 64));
77 ASSERT (aligned64_blocks
[i
] != NULL
);
78 ASSERT (((uintptr_t) aligned64_blocks
[i
] % 64) == 0);
79 memset (aligned64_blocks
[i
], 'z', size
);
82 for (i
= 0; i
< SIZEOF (sizes
); i
++)
84 free (aligned2_blocks
[i
]);
85 free (aligned4_blocks
[i
]);
86 free (aligned8_blocks
[i
]);
87 free (aligned16_blocks
[i
]);
88 free (aligned32_blocks
[i
]);
89 free (aligned64_blocks
[i
]);
92 return test_exit_status
;
94 fputs ("Skipping test: function 'aligned_alloc' does not exist\n", stderr
);