Commit da73a4ab authored by Richard Henderson's avatar Richard Henderson
Browse files

tcg: Allow multiple word entries into the constant pool 



This will be required for storing vector constants.

Reviewed-by: default avatarAlex Bennée <alex.bennee@linaro.org>
Reviewed-by: default avatarPeter Maydell <peter.maydell@linaro.org>
Signed-off-by: default avatarRichard Henderson <richard.henderson@linaro.org>
parent b256b89c

tcg/tcg-pool.inc.c

+92 −21
Original line number Diff line number Diff line
@@ -22,39 +22,110 @@ 


typedef struct TCGLabelPoolData {

    struct TCGLabelPoolData *next;

    tcg_target_ulong data;

    tcg_insn_unit *label;

    intptr_t addend;

    int type;

    int rtype;

    unsigned nlong;

    tcg_target_ulong data[];

} TCGLabelPoolData;





static void new_pool_label(TCGContext *s, tcg_target_ulong data, int type,

static TCGLabelPoolData *new_pool_alloc(TCGContext *s, int nlong, int rtype,

                                        tcg_insn_unit *label, intptr_t addend)

{

    TCGLabelPoolData *n = tcg_malloc(sizeof(*n));

    TCGLabelPoolData *i, **pp;

    TCGLabelPoolData *n = tcg_malloc(sizeof(TCGLabelPoolData)

                                     + sizeof(tcg_target_ulong) * nlong);



    n->data = data;

    n->label = label;

    n->type = type;

    n->addend = addend;

    n->rtype = rtype;

    n->nlong = nlong;

    return n;

}



static void new_pool_insert(TCGContext *s, TCGLabelPoolData *n)

{

    TCGLabelPoolData *i, **pp;

    int nlong = n->nlong;



    /* Insertion sort on the pool.  */

    for (pp = &s->pool_labels; (i = *pp) && i->data < data; pp = &i->next) {

    for (pp = &s->pool_labels; (i = *pp) != NULL; pp = &i->next) {

        if (nlong > i->nlong) {

            break;

        }

        if (nlong < i->nlong) {

            continue;

        }

        if (memcmp(n->data, i->data, sizeof(tcg_target_ulong) * nlong) >= 0) {

            break;

        }

    }

    n->next = *pp;

    *pp = n;

}



/* The "usual" for generic integer code.  */

static inline void new_pool_label(TCGContext *s, tcg_target_ulong d, int rtype,

                                  tcg_insn_unit *label, intptr_t addend)

{

    TCGLabelPoolData *n = new_pool_alloc(s, 1, rtype, label, addend);

    n->data[0] = d;

    new_pool_insert(s, n);

}



/* For v64 or v128, depending on the host.  */

static inline void new_pool_l2(TCGContext *s, int rtype, tcg_insn_unit *label,

                               intptr_t addend, tcg_target_ulong d0,

                               tcg_target_ulong d1)

{

    TCGLabelPoolData *n = new_pool_alloc(s, 2, rtype, label, addend);

    n->data[0] = d0;

    n->data[1] = d1;

    new_pool_insert(s, n);

}



/* For v128 or v256, depending on the host.  */

static inline void new_pool_l4(TCGContext *s, int rtype, tcg_insn_unit *label,

                               intptr_t addend, tcg_target_ulong d0,

                               tcg_target_ulong d1, tcg_target_ulong d2,

                               tcg_target_ulong d3)

{

    TCGLabelPoolData *n = new_pool_alloc(s, 4, rtype, label, addend);

    n->data[0] = d0;

    n->data[1] = d1;

    n->data[2] = d2;

    n->data[3] = d3;

    new_pool_insert(s, n);

}



/* For v256, for 32-bit host.  */

static inline void new_pool_l8(TCGContext *s, int rtype, tcg_insn_unit *label,

                               intptr_t addend, tcg_target_ulong d0,

                               tcg_target_ulong d1, tcg_target_ulong d2,

                               tcg_target_ulong d3, tcg_target_ulong d4,

                               tcg_target_ulong d5, tcg_target_ulong d6,

                               tcg_target_ulong d7)

{

    TCGLabelPoolData *n = new_pool_alloc(s, 8, rtype, label, addend);

    n->data[0] = d0;

    n->data[1] = d1;

    n->data[2] = d2;

    n->data[3] = d3;

    n->data[4] = d4;

    n->data[5] = d5;

    n->data[6] = d6;

    n->data[7] = d7;

    new_pool_insert(s, n);

}



/* To be provided by cpu/tcg-target.inc.c.  */

static void tcg_out_nop_fill(tcg_insn_unit *p, int count);



static bool tcg_out_pool_finalize(TCGContext *s)

{

    TCGLabelPoolData *p = s->pool_labels;

    tcg_target_ulong d, *a;

    TCGLabelPoolData *l = NULL;

    void *a;



    if (p == NULL) {

        return true;
@@ -62,24 +133,24 @@ static bool tcg_out_pool_finalize(TCGContext *s) 


    /* ??? Round up to qemu_icache_linesize, but then do not round

       again when allocating the next TranslationBlock structure.  */

    a = (void *)ROUND_UP((uintptr_t)s->code_ptr, sizeof(tcg_target_ulong));

    a = (void *)ROUND_UP((uintptr_t)s->code_ptr,

                         sizeof(tcg_target_ulong) * p->nlong);

    tcg_out_nop_fill(s->code_ptr, (tcg_insn_unit *)a - s->code_ptr);

    s->data_gen_ptr = a;



    /* Ensure the first comparison fails.  */

    d = p->data + 1;



    for (; p != NULL; p = p->next) {

        if (p->data != d) {

            d = p->data;

            if (unlikely((void *)a > s->code_gen_highwater)) {

        size_t size = sizeof(tcg_target_ulong) * p->nlong;

        if (!l || l->nlong != p->nlong || memcmp(l->data, p->data, size)) {

            if (unlikely(a > s->code_gen_highwater)) {

                return false;

            }

            *a++ = d;

            memcpy(a, p->data, size);

            a += size;

            l = p;

        }

        patch_reloc(p->label, p->type, (intptr_t)(a - 1), p->addend);

        patch_reloc(p->label, p->rtype, (intptr_t)a - size, p->addend);

    }



    s->code_ptr = (void *)a;

    s->code_ptr = a;

    return true;

}