ffmpeg-raspberry-pi/nasm/x86/disp8.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 1996-2013 The NASM Authors - All Rights Reserved
 *   See the file AUTHORS included with the NASM distribution for
 *   the specific copyright holders.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following
 *   conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *
 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ----------------------------------------------------------------------- */

/*
 * disp8.c   : Contains a common logic for EVEX compressed displacement
 */

#include "disp8.h"

/*
 * Find N value for compressed displacement (disp8 * N)
 */
uint8_t get_disp8N(insn *ins)
{
    static const uint8_t fv_n[2][2][VLMAX] = {{{16, 32, 64}, {4, 4, 4}},
                                              {{16, 32, 64}, {8, 8, 8}}};
    static const uint8_t hv_n[2][VLMAX]    =  {{8, 16, 32}, {4, 4, 4}};
    static const uint8_t dup_n[VLMAX]      =   {8, 32, 64};

    bool evex_b           = (ins->evex_p[2] & EVEX_P2B) >> 4;
    enum ttypes   tuple   = ins->evex_tuple;
    enum vectlens vectlen = (ins->evex_p[2] & EVEX_P2LL) >> 5;
    bool evex_w           = (ins->evex_p[1] & EVEX_P1W) >> 7;
    uint8_t n = 0;

    switch(tuple) {
    case FV:
        n = fv_n[evex_w][evex_b][vectlen];
        break;
    case HV:
        n = hv_n[evex_b][vectlen];
        break;

    case FVM:
        /* 16, 32, 64 for VL 128, 256, 512 respectively*/
        n = 1 << (vectlen + 4);
        break;
    case T1S8:  /* N = 1 */
    case T1S16: /* N = 2 */
        n = tuple - T1S8 + 1;
        break;
    case T1S:
        /* N = 4 for 32bit, 8 for 64bit */
        n = evex_w ? 8 : 4;
        break;
    case T1F32:
    case T1F64:
        /* N = 4 for 32bit, 8 for 64bit */
        n = (tuple == T1F32 ? 4 : 8);
        break;
    case T2:
    case T4:
    case T8:
        if (vectlen + 7 <= (evex_w + 5) + (tuple - T2 + 1))
            n = 0;
        else
            n = 1 << (tuple - T2 + evex_w + 3);
        break;
    case HVM:
    case QVM:
    case OVM:
        n = 1 << (OVM - tuple + vectlen + 1);
        break;
    case M128:
        n = 16;
        break;
    case DUP:
        n = dup_n[vectlen];
        break;

    default:
        break;
    }

    return n;
}

/*
 * Check if offset is a multiple of N with corresponding tuple type
 * if Disp8*N is available, compressed displacement is stored in compdisp
 */
bool is_disp8n(operand *input, insn *ins, int8_t *compdisp)
{
    int32_t off           = input->offset;
    uint8_t n;
    int32_t disp8;

    n = get_disp8N(ins);

    if (n && !(off & (n - 1))) {
        disp8 = off / n;
        /* if it fits in Disp8 */
        if (disp8 >= -128 && disp8 <= 127) {
            *compdisp = disp8;
            return true;
        }
    }

    *compdisp = 0;
    return false;
}