mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-23 04:42:32 +00:00
7518ba0a27
qfcc is putting two temps in the same location due to defspace_alloc_aligned_loc returning the same address when there was a hole caused by an earlier aligned alloc: specifically, a size-3 hole and a size-2 allocation with alignment-2.
151 lines
2.8 KiB
C
151 lines
2.8 KiB
C
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "tools/qfcc/include/class.h"
|
|
#include "tools/qfcc/include/expr.h"
|
|
#include "tools/qfcc/include/function.h"
|
|
#include "tools/qfcc/include/options.h"
|
|
#include "tools/qfcc/include/strpool.h"
|
|
#include "tools/qfcc/include/qfcc.h"
|
|
|
|
#include "tools/qfcc/test/test-defspace.h"
|
|
|
|
options_t options;
|
|
pr_info_t pr;
|
|
function_t *current_func;
|
|
class_type_t *current_class;
|
|
|
|
void
|
|
free_def (def_t *def)
|
|
{
|
|
if (0) free (def);
|
|
}
|
|
|
|
__attribute__((const))const char *
|
|
get_class_name (class_type_t *class_type, int prett)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
expr_t *
|
|
new_expr (void)
|
|
{
|
|
return calloc(1, sizeof (expr_t));
|
|
}
|
|
|
|
static int
|
|
check_init_state (const defspace_t *space, const char *name)
|
|
{
|
|
int pass = 1;
|
|
|
|
if (space->free_locs) {
|
|
printf ("%s free_locs not null\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->defs) {
|
|
printf ("%s defs not null\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->def_tail != &space->defs) {
|
|
printf ("%s def_tail not pointing to defs\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->data) {
|
|
printf ("%s data not null\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->size) {
|
|
printf ("%s size not 0\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->max_size) {
|
|
printf ("%s max_size not 0\n", name);
|
|
pass = 0;
|
|
}
|
|
if (!space->grow) {
|
|
printf ("%s grow is null\n", name);
|
|
pass = 0;
|
|
}
|
|
if (space->qfo_space) {
|
|
printf ("%s qfo_space not 0\n", name);
|
|
pass = 0;
|
|
}
|
|
return pass;
|
|
}
|
|
|
|
static int
|
|
test_init (void)
|
|
{
|
|
int pass = 1;
|
|
defspace_t *backed = defspace_new (ds_backed);
|
|
defspace_t *virtual = defspace_new (ds_virtual);
|
|
|
|
if (backed->grow == virtual->grow) {
|
|
printf ("expected different grow functions for backed and virtual\n");
|
|
pass = 0;
|
|
}
|
|
|
|
if (backed->type != ds_backed) {
|
|
printf ("backed ds has wrong type\n");
|
|
pass = 0;
|
|
}
|
|
|
|
if (virtual->type != ds_virtual) {
|
|
printf ("virtual ds has wrong type\n");
|
|
pass = 0;
|
|
}
|
|
|
|
pass &= check_init_state (backed, "backed");
|
|
pass &= check_init_state (virtual, "virtual");
|
|
|
|
return pass;
|
|
}
|
|
|
|
static int
|
|
test_aligned_alloc (void)
|
|
{
|
|
defspace_t *space = defspace_new (ds_virtual);
|
|
struct {
|
|
int size, align;
|
|
} allocations[6] = {
|
|
{ 2, 2 },
|
|
{ 2, 2 },
|
|
{ 1, 1 },
|
|
{ 4, 4 },
|
|
{ 2, 2 },
|
|
{ 2, 2 },
|
|
};
|
|
int offsets[6];
|
|
for (int i = 0; i < 6; i++) {
|
|
offsets[i] = defspace_alloc_aligned_loc (space, allocations[i].size,
|
|
allocations[i].align);
|
|
}
|
|
for (int i = 0; i < 5; i++) {
|
|
for (int j = i + 1; j < 6; j++) {
|
|
if (offsets[i] == offsets[j]) {
|
|
printf ("duplicate offset in allocations");
|
|
printf ("%d %d %d %d %d %d\n",
|
|
offsets[0], offsets[1], offsets[2],
|
|
offsets[3], offsets[4], offsets[5]);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
main (int argc, const char **argv)
|
|
{
|
|
pr.strings = strpool_new ();
|
|
|
|
int pass = 1;
|
|
|
|
pass &= test_init ();
|
|
pass &= test_aligned_alloc ();
|
|
|
|
return !pass;
|
|
}
|